use std::{
error::Error as StdError,
fmt,
future::{Future, pending},
pin::Pin,
sync::Arc,
time::{Duration, Instant},
};
use futures_core::Stream;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::{
AttemptId, BudgetRemaining, CapabilityIdentity, Failure, ModelCapabilities, ModelDescriptor,
ModelEvent, ModelProviderModelId, ModelProviderRequestId, ModelProviderResponseId,
ModelRequest, ModelResponse, ModelResponseMode, ModelUsage, RunId, SchemaReference, TenantId,
ThreadId, Timestamp, TokenCount,
};
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
pub type BoxStream<'a, T> = Pin<Box<dyn Stream<Item = T> + Send + 'a>>;
pub trait CancellationObserver: Send + Sync + 'static {
fn is_cancelled(&self) -> bool;
fn cancelled(&self) -> BoxFuture<'_, ()>;
}
#[derive(Clone)]
pub struct CancellationSignal {
observer: Arc<dyn CancellationObserver>,
}
impl CancellationSignal {
#[must_use]
pub fn new<O>(observer: O) -> Self
where
O: CancellationObserver,
{
Self {
observer: Arc::new(observer),
}
}
#[must_use]
pub fn from_shared(observer: Arc<dyn CancellationObserver>) -> Self {
Self { observer }
}
#[must_use]
pub fn never() -> Self {
Self::new(NeverCancelled)
}
#[must_use]
pub fn is_cancelled(&self) -> bool {
self.observer.is_cancelled()
}
pub fn cancelled(&self) -> BoxFuture<'_, ()> {
self.observer.cancelled()
}
}
impl Default for CancellationSignal {
fn default() -> Self {
Self::never()
}
}
impl fmt::Debug for CancellationSignal {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("CancellationSignal")
.field("cancelled", &self.is_cancelled())
.finish_non_exhaustive()
}
}
struct NeverCancelled;
impl CancellationObserver for NeverCancelled {
fn is_cancelled(&self) -> bool {
false
}
fn cancelled(&self) -> BoxFuture<'_, ()> {
Box::pin(pending())
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum ModelStopReason {
Cancelled,
DeadlineExceeded,
}
#[derive(Clone)]
pub struct ModelContext {
tenant_id: TenantId,
run_id: RunId,
thread_id: ThreadId,
attempt_id: AttemptId,
budget: BudgetRemaining,
observed_at: Timestamp,
deadline_instant: Instant,
cancellation: CancellationSignal,
}
impl ModelContext {
#[allow(clippy::too_many_arguments)]
pub fn new(
tenant_id: TenantId,
run_id: RunId,
thread_id: ThreadId,
attempt_id: AttemptId,
budget: BudgetRemaining,
observed_at: Timestamp,
observed_instant: Instant,
cancellation: CancellationSignal,
) -> Result<Self, ModelContextError> {
let deadline = budget.deadline();
let remaining_micros = i128::from(deadline.unix_micros())
.checked_sub(i128::from(observed_at.unix_micros()))
.expect("subtracting two i64 timestamps cannot overflow i128");
if remaining_micros <= 0 {
return Err(ModelContextError::DeadlineReached {
deadline,
observed_at,
});
}
let remaining_micros = u64::try_from(remaining_micros)
.expect("the supported timestamp range fits into u64 microseconds");
let remaining = Duration::from_micros(remaining_micros);
let deadline_instant = observed_instant
.checked_add(remaining)
.ok_or(ModelContextError::MonotonicDeadlineOutOfRange { remaining })?;
Ok(Self {
tenant_id,
run_id,
thread_id,
attempt_id,
budget,
observed_at,
deadline_instant,
cancellation,
})
}
#[must_use]
pub const fn tenant_id(&self) -> &TenantId {
&self.tenant_id
}
#[must_use]
pub const fn run_id(&self) -> RunId {
self.run_id
}
#[must_use]
pub const fn thread_id(&self) -> ThreadId {
self.thread_id
}
#[must_use]
pub const fn attempt_id(&self) -> AttemptId {
self.attempt_id
}
#[must_use]
pub const fn budget(&self) -> &BudgetRemaining {
&self.budget
}
#[must_use]
pub const fn observed_at(&self) -> Timestamp {
self.observed_at
}
#[must_use]
pub const fn deadline(&self) -> Timestamp {
self.budget.deadline()
}
#[must_use]
pub const fn deadline_instant(&self) -> Instant {
self.deadline_instant
}
#[must_use]
pub const fn cancellation(&self) -> &CancellationSignal {
&self.cancellation
}
#[must_use]
pub fn remaining_time_at(&self, observed_instant: Instant) -> Option<Duration> {
self.deadline_instant
.checked_duration_since(observed_instant)
.filter(|remaining| !remaining.is_zero())
}
#[must_use]
pub fn stop_reason_at(&self, observed_instant: Instant) -> Option<ModelStopReason> {
if self.cancellation.is_cancelled() {
Some(ModelStopReason::Cancelled)
} else if observed_instant >= self.deadline_instant {
Some(ModelStopReason::DeadlineExceeded)
} else {
None
}
}
}
impl fmt::Debug for ModelContext {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelContext")
.field("tenant_id", &self.tenant_id)
.field("run_id", &self.run_id)
.field("thread_id", &self.thread_id)
.field("attempt_id", &self.attempt_id)
.field("observed_at", &self.observed_at)
.field("deadline", &self.deadline())
.field("cancelled", &self.cancellation.is_cancelled())
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelContextError {
#[error("model context deadline {deadline} was reached at {observed_at}")]
DeadlineReached {
deadline: Timestamp,
observed_at: Timestamp,
},
#[error("model context monotonic deadline is out of range after {remaining:?}")]
MonotonicDeadlineOutOfRange {
remaining: Duration,
},
}
#[derive(
Clone, Copy, Debug, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum ModelErrorPhase {
Preparation,
Dispatch,
Response,
Stream,
}
#[derive(Clone, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ModelErrorProvenance {
attempt_id: AttemptId,
model: CapabilityIdentity,
#[serde(skip_serializing_if = "Option::is_none")]
provider_model_id: Option<ModelProviderModelId>,
#[serde(skip_serializing_if = "Option::is_none")]
provider_request_id: Option<ModelProviderRequestId>,
#[serde(skip_serializing_if = "Option::is_none")]
provider_response_id: Option<ModelProviderResponseId>,
}
impl ModelErrorProvenance {
#[must_use]
pub fn new(
attempt_id: AttemptId,
model: CapabilityIdentity,
provider_model_id: Option<ModelProviderModelId>,
provider_request_id: Option<ModelProviderRequestId>,
provider_response_id: Option<ModelProviderResponseId>,
) -> Self {
Self {
attempt_id,
model,
provider_model_id,
provider_request_id,
provider_response_id,
}
}
#[must_use]
pub const fn attempt_id(&self) -> AttemptId {
self.attempt_id
}
#[must_use]
pub const fn model(&self) -> &CapabilityIdentity {
&self.model
}
#[must_use]
pub const fn provider_model_id(&self) -> Option<&ModelProviderModelId> {
self.provider_model_id.as_ref()
}
#[must_use]
pub const fn provider_request_id(&self) -> Option<&ModelProviderRequestId> {
self.provider_request_id.as_ref()
}
#[must_use]
pub const fn provider_response_id(&self) -> Option<&ModelProviderResponseId> {
self.provider_response_id.as_ref()
}
}
impl fmt::Debug for ModelErrorProvenance {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelErrorProvenance")
.field("attempt_id", &self.attempt_id)
.field("model", &self.model)
.field("provider_model_id", &self.provider_model_id)
.field("provider_request_id", &self.provider_request_id)
.field("provider_response_id", &self.provider_response_id)
.finish_non_exhaustive()
}
}
#[derive(Clone, Deserialize, JsonSchema, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ModelError {
failure: Box<Failure>,
phase: ModelErrorPhase,
provenance: Box<ModelErrorProvenance>,
#[serde(skip_serializing_if = "Option::is_none")]
usage: Option<ModelUsage>,
}
impl ModelError {
#[must_use]
pub fn new(
failure: Failure,
phase: ModelErrorPhase,
provenance: ModelErrorProvenance,
usage: Option<ModelUsage>,
) -> Self {
Self {
failure: Box::new(failure),
phase,
provenance: Box::new(provenance),
usage,
}
}
pub fn validate_for(
&self,
context: &ModelContext,
descriptor: &ModelDescriptor,
request: &ModelRequest,
) -> Result<(), ModelErrorValidationError> {
self.validate_for_attempt(context.attempt_id, descriptor, request)
}
pub fn validate_for_attempt(
&self,
attempt_id: AttemptId,
descriptor: &ModelDescriptor,
request: &ModelRequest,
) -> Result<(), ModelErrorValidationError> {
if self.provenance.attempt_id != attempt_id {
return Err(ModelErrorValidationError::AttemptMismatch {
expected: attempt_id,
actual: self.provenance.attempt_id,
});
}
let expected_model = descriptor.metadata().identity();
if &self.provenance.model != expected_model {
return Err(ModelErrorValidationError::ModelIdentityMismatch {
expected: Box::new(expected_model.clone()),
actual: Box::new(self.provenance.model.clone()),
});
}
let phase_matches_mode = match self.phase {
ModelErrorPhase::Preparation | ModelErrorPhase::Dispatch => true,
ModelErrorPhase::Response => request.response_mode() == ModelResponseMode::Complete,
ModelErrorPhase::Stream => request.response_mode() == ModelResponseMode::Streaming,
};
if !phase_matches_mode {
return Err(ModelErrorValidationError::PhaseResponseModeMismatch {
phase: self.phase,
response_mode: request.response_mode(),
});
}
if let Some(usage) = &self.usage {
if usage.input_tokens() > request.limits().max_input_tokens() {
return Err(ModelErrorValidationError::InputUsageExceedsRequest {
maximum: request.limits().max_input_tokens(),
actual: usage.input_tokens(),
});
}
if usage.output_tokens() > request.limits().max_output_tokens() {
return Err(ModelErrorValidationError::OutputUsageExceedsRequest {
maximum: request.limits().max_output_tokens(),
actual: usage.output_tokens(),
});
}
}
Ok(())
}
#[must_use]
pub const fn failure(&self) -> &Failure {
&self.failure
}
#[must_use]
pub fn into_failure(self) -> Failure {
*self.failure
}
#[must_use]
pub const fn phase(&self) -> ModelErrorPhase {
self.phase
}
#[must_use]
pub const fn provenance(&self) -> &ModelErrorProvenance {
&self.provenance
}
#[must_use]
pub const fn usage(&self) -> Option<&ModelUsage> {
self.usage.as_ref()
}
}
impl fmt::Debug for ModelError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelError")
.field("failure", &self.failure)
.field("phase", &self.phase)
.field("provenance", &self.provenance)
.field("usage", &self.usage)
.finish_non_exhaustive()
}
}
impl fmt::Display for ModelError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.failure, formatter)
}
}
impl StdError for ModelError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
Some(&self.failure)
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelErrorValidationError {
#[error("model failure attempt {actual} does not match context attempt {expected}")]
AttemptMismatch {
expected: AttemptId,
actual: AttemptId,
},
#[error("model failure identity {actual:?} does not match descriptor {expected:?}")]
ModelIdentityMismatch {
expected: Box<CapabilityIdentity>,
actual: Box<CapabilityIdentity>,
},
#[error("model failure phase {phase:?} is invalid for {response_mode:?} delivery")]
PhaseResponseModeMismatch {
phase: ModelErrorPhase,
response_mode: ModelResponseMode,
},
#[error("failed model attempt input usage {actual} exceeds request maximum {maximum}")]
InputUsageExceedsRequest {
maximum: TokenCount,
actual: TokenCount,
},
#[error("failed model attempt output usage {actual} exceeds request maximum {maximum}")]
OutputUsageExceedsRequest {
maximum: TokenCount,
actual: TokenCount,
},
}
pub trait Model: Send + Sync + 'static {
fn descriptor(&self) -> &ModelDescriptor;
fn capabilities(&self) -> &ModelCapabilities {
self.descriptor().capabilities()
}
fn invoke(
&self,
context: ModelContext,
request: ModelRequest,
) -> BoxFuture<'_, Result<ModelResponse, ModelError>>;
fn stream(
&self,
context: ModelContext,
request: ModelRequest,
) -> BoxStream<'_, Result<ModelEvent, ModelError>>;
}
pub trait ModelSchemaRegistry: crate::GraphSchemaValidator + Send + Sync + 'static {
fn canonical_schema_bytes(&self, schema: &SchemaReference) -> Option<&[u8]>;
}
#[cfg(test)]
mod tests {
use std::{
pin::Pin,
task::{Context, Poll},
};
use serde_json::{Value, json, to_value};
use super::*;
use crate::{
BudgetUsage, DurationMillis, FailureCategory, FailureCode, FailureId, FailureMessage,
FailureOrigin, ResolvedBudget, RetryAdvice,
};
const ATTEMPT_ID: &str = "01912345-6789-7abc-8def-0123456789ab";
const RUN_ID: &str = "01912345-6789-7abc-8def-0123456789ac";
const THREAD_ID: &str = "01912345-6789-7abc-8def-0123456789ad";
const FAILURE_ID: &str = "01912345-6789-7abc-8def-0123456789ae";
const OBSERVED_AT: &str = "2029-12-31T23:59:59.000000Z";
struct AlwaysCancelled;
impl CancellationObserver for AlwaysCancelled {
fn is_cancelled(&self) -> bool {
true
}
fn cancelled(&self) -> BoxFuture<'_, ()> {
Box::pin(async {})
}
}
fn descriptor() -> ModelDescriptor {
let fixture: Value = serde_json::from_str(include_str!(
"../tests/fixtures/core-model-descriptor-v1.json"
))
.unwrap();
serde_json::from_value(fixture["descriptors"]["valid"][0].clone()).unwrap()
}
fn request(response_mode: ModelResponseMode) -> ModelRequest {
let fixture: Value =
serde_json::from_str(include_str!("../tests/fixtures/core-model-request-v1.json"))
.unwrap();
let mut value = fixture["requests"]["valid"][0].clone();
if response_mode == ModelResponseMode::Streaming {
value["response_mode"] = Value::from("streaming");
value["requirements"]["streaming"] = Value::Bool(true);
}
serde_json::from_value(value).unwrap()
}
fn remaining_budget(observed_at: Timestamp) -> BudgetRemaining {
let fixture: Value =
serde_json::from_str(include_str!("../tests/fixtures/core-budget-v1.json")).unwrap();
let resolved =
serde_json::from_value::<ResolvedBudget>(fixture["resolved"]["valid"][0].clone())
.unwrap();
resolved
.remaining(&BudgetUsage::zero(), observed_at)
.unwrap()
}
fn context_with(cancellation: CancellationSignal) -> ModelContext {
let observed_at = OBSERVED_AT.parse::<Timestamp>().unwrap();
ModelContext::new(
TenantId::new("tenant-production").unwrap(),
RUN_ID.parse().unwrap(),
THREAD_ID.parse().unwrap(),
ATTEMPT_ID.parse().unwrap(),
remaining_budget(observed_at),
observed_at,
Instant::now(),
cancellation,
)
.unwrap()
}
fn failure() -> Failure {
Failure::new(
FAILURE_ID.parse::<FailureId>().unwrap(),
FailureCategory::RateLimited,
FailureCode::new("provider.rate_limited").unwrap(),
FailureOrigin::new("provider.example").unwrap(),
FailureMessage::new("The model provider is temporarily unavailable.").unwrap(),
RetryAdvice::SafeAfter {
delay: DurationMillis::new(250).unwrap(),
},
)
.unwrap()
}
fn provenance(descriptor: &ModelDescriptor, attempt_id: AttemptId) -> ModelErrorProvenance {
ModelErrorProvenance::new(
attempt_id,
descriptor.metadata().identity().clone(),
Some(ModelProviderModelId::new("provider-model-v1").unwrap()),
Some(ModelProviderRequestId::new("req_01JABCDEF").unwrap()),
Some(ModelProviderResponseId::new("resp_01JABCDEF").unwrap()),
)
}
#[test]
fn cancellation_signal_is_runtime_neutral_cloneable_and_redacted() {
let never = CancellationSignal::never();
assert!(!never.is_cancelled());
assert_eq!(
format!("{never:?}"),
"CancellationSignal { cancelled: false, .. }"
);
let cancelled = CancellationSignal::new(AlwaysCancelled);
assert!(cancelled.is_cancelled());
assert!(cancelled.clone().is_cancelled());
assert_eq!(
format!("{cancelled:?}"),
"CancellationSignal { cancelled: true, .. }"
);
}
#[test]
fn model_context_derives_a_finite_monotonic_deadline() {
let observed_at = OBSERVED_AT.parse::<Timestamp>().unwrap();
let observed_instant = Instant::now();
let context = ModelContext::new(
TenantId::new("tenant-production").unwrap(),
RUN_ID.parse().unwrap(),
THREAD_ID.parse().unwrap(),
ATTEMPT_ID.parse().unwrap(),
remaining_budget(observed_at),
observed_at,
observed_instant,
CancellationSignal::never(),
)
.unwrap();
let expected_remaining = Duration::from_secs(1);
assert_eq!(context.observed_at(), observed_at);
assert_eq!(
context.remaining_time_at(observed_instant),
Some(expected_remaining)
);
assert_eq!(
context.deadline_instant(),
observed_instant + expected_remaining
);
assert_eq!(context.stop_reason_at(observed_instant), None);
assert_eq!(
context.stop_reason_at(context.deadline_instant()),
Some(ModelStopReason::DeadlineExceeded)
);
assert_eq!(context.remaining_time_at(context.deadline_instant()), None);
}
#[test]
fn model_context_rejects_reached_deadlines_and_cancellation_wins() {
let observed_at = "2030-01-01T00:00:00.000000Z".parse::<Timestamp>().unwrap();
let error = ModelContext::new(
TenantId::new("tenant-production").unwrap(),
RUN_ID.parse().unwrap(),
THREAD_ID.parse().unwrap(),
ATTEMPT_ID.parse().unwrap(),
remaining_budget(OBSERVED_AT.parse().unwrap()),
observed_at,
Instant::now(),
CancellationSignal::never(),
)
.unwrap_err();
assert!(matches!(error, ModelContextError::DeadlineReached { .. }));
let context = context_with(CancellationSignal::new(AlwaysCancelled));
assert_eq!(
context.stop_reason_at(context.deadline_instant()),
Some(ModelStopReason::Cancelled)
);
}
#[test]
fn model_context_debug_omits_budget_values_and_monotonic_clock() {
let context = context_with(CancellationSignal::never());
let debug = format!("{context:?}");
assert!(debug.contains("tenant-production"));
assert!(debug.contains(ATTEMPT_ID));
assert!(!debug.contains("1000000"));
assert!(!debug.contains("Instant"));
}
#[test]
fn model_error_round_trips_public_evidence_without_leaking_identifiers() {
let descriptor = descriptor();
let error = ModelError::new(
failure(),
ModelErrorPhase::Stream,
provenance(&descriptor, ATTEMPT_ID.parse().unwrap()),
Some(ModelUsage::new(TokenCount::new(120), None, TokenCount::new(7), None).unwrap()),
);
let value = to_value(&error).unwrap();
assert_eq!(value["phase"], "stream");
assert_eq!(value["provenance"]["provider_request_id"], "req_01JABCDEF");
let decoded = serde_json::from_value::<ModelError>(value.clone()).unwrap();
assert_eq!(to_value(decoded).unwrap(), value);
assert_eq!(
error.to_string(),
"The model provider is temporarily unavailable."
);
let debug = format!("{error:?}");
assert!(!debug.contains("req_01JABCDEF"));
assert!(!debug.contains("resp_01JABCDEF"));
assert!(!debug.contains("provider-model-v1"));
assert!(!debug.contains("temporarily unavailable"));
}
#[test]
fn model_error_validation_binds_attempt_mode_model_and_usage() {
let descriptor = descriptor();
let context = context_with(CancellationSignal::never());
let complete = request(ModelResponseMode::Complete);
let valid = ModelError::new(
failure(),
ModelErrorPhase::Response,
provenance(&descriptor, context.attempt_id()),
Some(ModelUsage::new(TokenCount::new(120), None, TokenCount::new(7), None).unwrap()),
);
valid
.validate_for(&context, &descriptor, &complete)
.unwrap();
let wrong_attempt = ModelError::new(
failure(),
ModelErrorPhase::Response,
provenance(&descriptor, RUN_ID.parse::<AttemptId>().unwrap()),
None,
);
assert!(matches!(
wrong_attempt.validate_for(&context, &descriptor, &complete),
Err(ModelErrorValidationError::AttemptMismatch { .. })
));
let wrong_phase = ModelError::new(
failure(),
ModelErrorPhase::Stream,
provenance(&descriptor, context.attempt_id()),
None,
);
assert_eq!(
wrong_phase.validate_for(&context, &descriptor, &complete),
Err(ModelErrorValidationError::PhaseResponseModeMismatch {
phase: ModelErrorPhase::Stream,
response_mode: ModelResponseMode::Complete,
})
);
let excessive = ModelError::new(
failure(),
ModelErrorPhase::Response,
provenance(&descriptor, context.attempt_id()),
Some(
ModelUsage::new(
TokenCount::new(complete.limits().max_input_tokens().get() + 1),
None,
TokenCount::ZERO,
None,
)
.unwrap(),
),
);
assert!(matches!(
excessive.validate_for(&context, &descriptor, &complete),
Err(ModelErrorValidationError::InputUsageExceedsRequest { .. })
));
}
#[test]
fn response_provenance_preserves_provider_request_correlation() {
let descriptor = descriptor();
let provenance = crate::ModelResponseProvenance::new(
ATTEMPT_ID.parse().unwrap(),
descriptor.metadata().identity().clone(),
None,
None,
)
.with_provider_request_id(ModelProviderRequestId::new("req_01JABCDEF").unwrap());
assert_eq!(
provenance.provider_request_id().unwrap().as_str(),
"req_01JABCDEF"
);
assert_eq!(
to_value(&provenance).unwrap()["provider_request_id"],
"req_01JABCDEF"
);
assert!(!format!("{provenance:?}").contains("req_01JABCDEF"));
}
struct EmptyStream;
impl Stream for EmptyStream {
type Item = Result<ModelEvent, ModelError>;
fn poll_next(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Poll::Ready(None)
}
}
struct FakeModel {
descriptor: ModelDescriptor,
}
impl Model for FakeModel {
fn descriptor(&self) -> &ModelDescriptor {
&self.descriptor
}
fn invoke(
&self,
_: ModelContext,
_: ModelRequest,
) -> BoxFuture<'_, Result<ModelResponse, ModelError>> {
Box::pin(pending())
}
fn stream(
&self,
_: ModelContext,
_: ModelRequest,
) -> BoxStream<'_, Result<ModelEvent, ModelError>> {
Box::pin(EmptyStream)
}
}
#[test]
fn model_trait_is_object_safe_and_boundary_values_are_send_sync() {
fn assert_send_sync<T: Send + Sync>() {}
fn accept_object(_: &dyn Model) {}
assert_send_sync::<ModelContext>();
assert_send_sync::<ModelError>();
assert_send_sync::<CancellationSignal>();
let model = FakeModel {
descriptor: descriptor(),
};
accept_object(&model);
assert_eq!(model.capabilities(), model.descriptor().capabilities());
}
#[test]
fn model_error_schemas_are_closed_and_wire_rejects_unknown_fields() {
for schema in [
to_value(schemars::schema_for!(ModelErrorProvenance)).unwrap(),
to_value(schemars::schema_for!(ModelError)).unwrap(),
] {
assert_eq!(schema["type"], "object");
assert_eq!(schema["additionalProperties"], false);
}
let descriptor = descriptor();
let error = ModelError::new(
failure(),
ModelErrorPhase::Dispatch,
provenance(&descriptor, ATTEMPT_ID.parse().unwrap()),
None,
);
let mut value = to_value(error).unwrap();
value["provider_payload"] = json!({ "secret": true });
assert!(serde_json::from_value::<ModelError>(value).is_err());
}
}