use std::{fmt, str::FromStr};
use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
use thiserror::Error;
use crate::decimal::{UnsignedDecimalError, parse_bounded_u64};
use crate::{
AttemptId, CapabilityLifecycleState, Digest, InvocationId, JournalHead, JournalSequence,
ModelCapabilityMismatch, ModelDescriptor, ModelError, ModelErrorPhase,
ModelErrorValidationError, ModelRequest, ModelResponse, ModelResponseError, NodeActivation,
RunId, TenantId, Timestamp,
};
const MAX_DATABASE_ORDINAL: u64 = i64::MAX as u64;
const INVOCATION_REVISION_PATTERN: &str = "^(0|[1-9][0-9]{0,18})$";
const INTENT_DIGEST_DOMAIN: &[u8] = b"stateknot-model-invocation-intent-v1\0";
const TRANSITION_DIGEST_DOMAIN: &[u8] = b"stateknot-model-invocation-transition-v1\0";
const RECORD_DIGEST_DOMAIN: &[u8] = b"stateknot-model-invocation-record-v1\0";
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ModelInvocationRevision(u64);
impl ModelInvocationRevision {
pub const INITIAL: Self = Self(0);
pub const MAX: Self = Self(MAX_DATABASE_ORDINAL);
pub const fn new(value: u64) -> Result<Self, ModelInvocationRevisionError> {
if value > MAX_DATABASE_ORDINAL {
return Err(ModelInvocationRevisionError::AboveMaximum);
}
Ok(Self(value))
}
#[must_use]
pub const fn get(self) -> u64 {
self.0
}
#[must_use]
pub const fn checked_next(self) -> Option<Self> {
if self.0 == MAX_DATABASE_ORDINAL {
None
} else {
Some(Self(self.0 + 1))
}
}
}
impl fmt::Display for ModelInvocationRevision {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(formatter)
}
}
impl FromStr for ModelInvocationRevision {
type Err = ModelInvocationRevisionError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
let value = parse_bounded_u64(value, MAX_DATABASE_ORDINAL)
.map_err(ModelInvocationRevisionError::from_decimal_error)?;
Self::new(value)
}
}
impl Serialize for ModelInvocationRevision {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(self)
}
}
impl<'de> Deserialize<'de> for ModelInvocationRevision {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(ModelInvocationRevisionVisitor)
}
}
struct ModelInvocationRevisionVisitor;
impl de::Visitor<'_> for ModelInvocationRevisionVisitor {
type Value = ModelInvocationRevision;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a canonical non-negative decimal PostgreSQL BIGINT revision")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
value.parse().map_err(E::custom)
}
}
impl JsonSchema for ModelInvocationRevision {
fn schema_name() -> std::borrow::Cow<'static, str> {
"ModelInvocationRevision".into()
}
fn schema_id() -> std::borrow::Cow<'static, str> {
concat!(module_path!(), "::ModelInvocationRevision").into()
}
fn json_schema(_: &mut SchemaGenerator) -> Schema {
json_schema!({
"type": "string",
"minLength": 1,
"maxLength": 19,
"pattern": INVOCATION_REVISION_PATTERN
})
}
fn inline_schema() -> bool {
true
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationRevisionError {
#[error("model invocation revision must contain only unsigned ASCII decimal digits")]
InvalidFormat,
#[error("model invocation revision must use canonical decimal text")]
NonCanonical,
#[error("model invocation revision exceeds the PostgreSQL BIGINT maximum")]
AboveMaximum,
}
impl ModelInvocationRevisionError {
const fn from_decimal_error(error: UnsignedDecimalError) -> Self {
match error {
UnsignedDecimalError::Empty | UnsignedDecimalError::InvalidCharacter { .. } => {
Self::InvalidFormat
}
UnsignedDecimalError::LeadingZero => Self::NonCanonical,
UnsignedDecimalError::TooLong { .. } | UnsignedDecimalError::Overflow => {
Self::AboveMaximum
}
}
}
}
#[derive(Clone, Eq, JsonSchema, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ModelInvocationIntent {
activation: NodeActivation,
invocation_id: InvocationId,
descriptor: ModelDescriptor,
request: ModelRequest,
intent_digest: Digest,
}
impl ModelInvocationIntent {
pub fn new(
activation: NodeActivation,
invocation_id: InvocationId,
descriptor: ModelDescriptor,
request: ModelRequest,
) -> Result<Self, ModelInvocationIntentError> {
validate_intent_shape(&descriptor, &request)?;
let intent_digest = compute_intent_digest(&ModelInvocationIntentDigestWire {
activation: &activation,
invocation_id,
descriptor: &descriptor,
request: &request,
})?;
Ok(Self {
activation,
invocation_id,
descriptor,
request,
intent_digest,
})
}
pub fn restore(
activation: NodeActivation,
invocation_id: InvocationId,
descriptor: ModelDescriptor,
request: ModelRequest,
intent_digest: Digest,
) -> Result<Self, ModelInvocationIntentError> {
let restored = Self::new(activation, invocation_id, descriptor, request)?;
if restored.intent_digest != intent_digest {
return Err(ModelInvocationIntentError::DigestMismatch);
}
Ok(restored)
}
#[must_use]
pub const fn activation(&self) -> &NodeActivation {
&self.activation
}
#[must_use]
pub const fn invocation_id(&self) -> InvocationId {
self.invocation_id
}
#[must_use]
pub const fn descriptor(&self) -> &ModelDescriptor {
&self.descriptor
}
#[must_use]
pub const fn request(&self) -> &ModelRequest {
&self.request
}
#[must_use]
pub const fn intent_digest(&self) -> Digest {
self.intent_digest
}
#[must_use]
pub const fn tenant_id(&self) -> &TenantId {
self.activation.tenant_id()
}
#[must_use]
pub const fn run_id(&self) -> RunId {
self.activation.run_id()
}
}
impl fmt::Debug for ModelInvocationIntent {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelInvocationIntent")
.field("activation", &self.activation)
.field("invocation_id", &self.invocation_id)
.field("descriptor", &self.descriptor)
.field("request", &self.request)
.field("intent_digest", &self.intent_digest)
.finish_non_exhaustive()
}
}
impl<'de> Deserialize<'de> for ModelInvocationIntent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Wire {
activation: NodeActivation,
invocation_id: InvocationId,
descriptor: ModelDescriptor,
request: ModelRequest,
intent_digest: Digest,
}
let wire = Wire::deserialize(deserializer)?;
Self::restore(
wire.activation,
wire.invocation_id,
wire.descriptor,
wire.request,
wire.intent_digest,
)
.map_err(de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationIntentError {
#[error("retired model binding cannot be selected for a new invocation")]
RetiredModel,
#[error("model binding does not satisfy the invocation request: {mismatch:?}")]
CapabilityMismatch {
mismatch: Box<ModelCapabilityMismatch>,
},
#[error("model invocation intent integrity calculation failed: {source}")]
Integrity {
#[source]
source: ModelInvocationIntegrityError,
},
#[error("model invocation intent digest does not match its fields")]
DigestMismatch,
}
impl From<ModelInvocationIntegrityError> for ModelInvocationIntentError {
fn from(source: ModelInvocationIntegrityError) -> Self {
Self::Integrity { source }
}
}
#[derive(
Clone, Copy, Debug, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
)]
#[serde(rename_all = "snake_case")]
pub enum ModelInvocationStatus {
Prepared,
Executing,
Committed,
Failed,
}
#[derive(Clone, Debug, JsonSchema, Serialize)]
#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)]
#[allow(clippy::large_enum_variant)]
pub enum ModelInvocationState {
Prepared,
Executing {
attempt_id: AttemptId,
},
Committed {
response: ModelResponse,
},
Failed {
error: ModelError,
},
}
impl ModelInvocationState {
#[must_use]
pub const fn status(&self) -> ModelInvocationStatus {
match self {
Self::Prepared => ModelInvocationStatus::Prepared,
Self::Executing { .. } => ModelInvocationStatus::Executing,
Self::Committed { .. } => ModelInvocationStatus::Committed,
Self::Failed { .. } => ModelInvocationStatus::Failed,
}
}
#[must_use]
pub const fn attempt_id(&self) -> Option<AttemptId> {
match self {
Self::Prepared => None,
Self::Executing { attempt_id } => Some(*attempt_id),
Self::Committed { response } => Some(response.provenance().attempt_id()),
Self::Failed { error } => Some(error.provenance().attempt_id()),
}
}
}
impl<'de> Deserialize<'de> for ModelInvocationState {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)]
#[allow(clippy::large_enum_variant)]
enum Wire {
Prepared,
Executing { attempt_id: AttemptId },
Committed { response: ModelResponse },
Failed { error: ModelError },
}
Ok(match Wire::deserialize(deserializer)? {
Wire::Prepared => Self::Prepared,
Wire::Executing { attempt_id } => Self::Executing { attempt_id },
Wire::Committed { response } => Self::Committed { response },
Wire::Failed { error } => Self::Failed { error },
})
}
}
#[derive(
Clone, Copy, Debug, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
)]
#[serde(rename_all = "snake_case")]
pub enum ModelInvocationTransitionKind {
StartAttempt,
RecordResponse,
RecordError,
}
#[derive(Clone, Debug, Deserialize, JsonSchema, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
#[allow(clippy::large_enum_variant)]
pub enum ModelInvocationTransition {
StartAttempt {
attempt_id: AttemptId,
},
RecordResponse {
response: ModelResponse,
},
RecordError {
error: ModelError,
},
}
impl ModelInvocationTransition {
#[must_use]
pub const fn kind(&self) -> ModelInvocationTransitionKind {
match self {
Self::StartAttempt { .. } => ModelInvocationTransitionKind::StartAttempt,
Self::RecordResponse { .. } => ModelInvocationTransitionKind::RecordResponse,
Self::RecordError { .. } => ModelInvocationTransitionKind::RecordError,
}
}
}
#[derive(Clone, Debug, Eq, JsonSchema, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ModelInvocationHead {
tenant_id: TenantId,
run_id: RunId,
invocation_id: InvocationId,
revision: ModelInvocationRevision,
status: ModelInvocationStatus,
#[serde(skip_serializing_if = "Option::is_none")]
attempt_id: Option<AttemptId>,
journal_head: JournalHead,
digest: Digest,
}
impl ModelInvocationHead {
#[allow(clippy::too_many_arguments)]
pub fn new(
tenant_id: TenantId,
run_id: RunId,
invocation_id: InvocationId,
revision: ModelInvocationRevision,
status: ModelInvocationStatus,
attempt_id: Option<AttemptId>,
journal_head: JournalHead,
digest: Digest,
) -> Result<Self, ModelInvocationHeadError> {
validate_journal_scope(&tenant_id, run_id, &journal_head)
.map_err(ModelInvocationHeadError::from_scope)?;
validate_status_attempt(status, attempt_id)?;
validate_revision_status(revision, status)?;
Ok(Self {
tenant_id,
run_id,
invocation_id,
revision,
status,
attempt_id,
journal_head,
digest,
})
}
#[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 invocation_id(&self) -> InvocationId {
self.invocation_id
}
#[must_use]
pub const fn revision(&self) -> ModelInvocationRevision {
self.revision
}
#[must_use]
pub const fn status(&self) -> ModelInvocationStatus {
self.status
}
#[must_use]
pub const fn attempt_id(&self) -> Option<AttemptId> {
self.attempt_id
}
#[must_use]
pub const fn journal_head(&self) -> &JournalHead {
&self.journal_head
}
#[must_use]
pub const fn digest(&self) -> Digest {
self.digest
}
}
impl<'de> Deserialize<'de> for ModelInvocationHead {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Wire {
tenant_id: TenantId,
run_id: RunId,
invocation_id: InvocationId,
revision: ModelInvocationRevision,
status: ModelInvocationStatus,
attempt_id: Option<AttemptId>,
journal_head: JournalHead,
digest: Digest,
}
let wire = Wire::deserialize(deserializer)?;
Self::new(
wire.tenant_id,
wire.run_id,
wire.invocation_id,
wire.revision,
wire.status,
wire.attempt_id,
wire.journal_head,
wire.digest,
)
.map_err(de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationHeadError {
#[error("model invocation journal head crosses the tenant boundary")]
JournalTenantMismatch,
#[error("model invocation journal head does not belong to the run")]
JournalRunMismatch,
#[error("prepared model invocation head must not contain an attempt")]
PreparedHasAttempt,
#[error("non-prepared model invocation head must contain an attempt")]
AttemptMissing,
#[error("model invocation head revision zero must be prepared")]
InitialStatusMismatch,
#[error("prepared model invocation head must use revision zero")]
PreparedRevisionMismatch,
}
impl ModelInvocationHeadError {
const fn from_scope(error: InvocationScopeError) -> Self {
match error {
InvocationScopeError::Tenant => Self::JournalTenantMismatch,
InvocationScopeError::Run => Self::JournalRunMismatch,
}
}
}
#[derive(Clone, JsonSchema, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ModelInvocation {
intent: ModelInvocationIntent,
revision: ModelInvocationRevision,
state: ModelInvocationState,
#[serde(skip_serializing_if = "Option::is_none")]
previous: Option<ModelInvocationHead>,
journal_head: JournalHead,
#[serde(skip_serializing_if = "Option::is_none")]
transition: Option<ModelInvocationTransition>,
#[serde(skip_serializing_if = "Option::is_none")]
transition_digest: Option<Digest>,
digest: Digest,
}
impl ModelInvocation {
pub fn prepare(
intent: ModelInvocationIntent,
journal_head: JournalHead,
) -> Result<Self, ModelInvocationError> {
validate_preparation_journal(&intent, &journal_head)?;
let revision = ModelInvocationRevision::INITIAL;
let state = ModelInvocationState::Prepared;
let digest = compute_record_digest(&ModelInvocationRecordDigestWire {
intent_digest: intent.intent_digest,
revision,
state: &state,
previous: None,
journal_head: &journal_head,
transition_digest: None,
})?;
Ok(Self {
intent,
revision,
state,
previous: None,
journal_head,
transition: None,
transition_digest: None,
digest,
})
}
pub fn advance(
&self,
transition: ModelInvocationTransition,
journal_head: JournalHead,
) -> Result<Self, ModelInvocationError> {
validate_successor_journal(self, &journal_head)?;
let revision = self
.revision
.checked_next()
.ok_or(ModelInvocationError::RevisionOverflow)?;
let state = apply_transition(self, &transition, journal_head.recorded_at())?;
let transition_digest = compute_transition_digest(&transition)?;
let previous = self.head();
let digest = compute_record_digest(&ModelInvocationRecordDigestWire {
intent_digest: self.intent.intent_digest,
revision,
state: &state,
previous: Some(&previous),
journal_head: &journal_head,
transition_digest: Some(transition_digest),
})?;
Ok(Self {
intent: self.intent.clone(),
revision,
state,
previous: Some(previous),
journal_head,
transition: Some(transition),
transition_digest: Some(transition_digest),
digest,
})
}
#[allow(clippy::too_many_arguments)]
pub fn restore(
intent: ModelInvocationIntent,
revision: ModelInvocationRevision,
state: ModelInvocationState,
previous: Option<ModelInvocationHead>,
journal_head: JournalHead,
transition: Option<ModelInvocationTransition>,
transition_digest: Option<Digest>,
digest: Digest,
) -> Result<Self, ModelInvocationError> {
validate_record_shape(
&intent,
revision,
&state,
previous.as_ref(),
&journal_head,
transition.as_ref(),
transition_digest,
)?;
let expected = compute_record_digest(&ModelInvocationRecordDigestWire {
intent_digest: intent.intent_digest,
revision,
state: &state,
previous: previous.as_ref(),
journal_head: &journal_head,
transition_digest,
})?;
if digest != expected {
return Err(ModelInvocationError::DigestMismatch);
}
Ok(Self {
intent,
revision,
state,
previous,
journal_head,
transition,
transition_digest,
digest,
})
}
#[must_use]
pub const fn intent(&self) -> &ModelInvocationIntent {
&self.intent
}
#[must_use]
pub const fn revision(&self) -> ModelInvocationRevision {
self.revision
}
#[must_use]
pub const fn state(&self) -> &ModelInvocationState {
&self.state
}
#[must_use]
pub const fn status(&self) -> ModelInvocationStatus {
self.state.status()
}
#[must_use]
pub const fn attempt_id(&self) -> Option<AttemptId> {
self.state.attempt_id()
}
#[must_use]
pub const fn previous(&self) -> Option<&ModelInvocationHead> {
self.previous.as_ref()
}
#[must_use]
pub const fn journal_head(&self) -> &JournalHead {
&self.journal_head
}
#[must_use]
pub const fn transition(&self) -> Option<&ModelInvocationTransition> {
self.transition.as_ref()
}
#[must_use]
pub const fn transition_digest(&self) -> Option<Digest> {
self.transition_digest
}
#[must_use]
pub const fn digest(&self) -> Digest {
self.digest
}
#[must_use]
pub fn head(&self) -> ModelInvocationHead {
ModelInvocationHead {
tenant_id: self.intent.tenant_id().clone(),
run_id: self.intent.run_id(),
invocation_id: self.intent.invocation_id,
revision: self.revision,
status: self.status(),
attempt_id: self.attempt_id(),
journal_head: self.journal_head.clone(),
digest: self.digest,
}
}
}
impl fmt::Debug for ModelInvocation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelInvocation")
.field("intent", &self.intent)
.field("revision", &self.revision)
.field("state", &self.state)
.field("previous", &self.previous)
.field("journal_head", &self.journal_head)
.field("transition", &self.transition)
.field("transition_digest", &self.transition_digest)
.field("digest", &self.digest)
.finish_non_exhaustive()
}
}
impl<'de> Deserialize<'de> for ModelInvocation {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Wire {
intent: ModelInvocationIntent,
revision: ModelInvocationRevision,
state: ModelInvocationState,
previous: Option<ModelInvocationHead>,
journal_head: JournalHead,
transition: Option<ModelInvocationTransition>,
transition_digest: Option<Digest>,
digest: Digest,
}
let wire = Wire::deserialize(deserializer)?;
Self::restore(
wire.intent,
wire.revision,
wire.state,
wire.previous,
wire.journal_head,
wire.transition,
wire.transition_digest,
wire.digest,
)
.map_err(de::Error::custom)
}
}
#[derive(Clone, Debug, Default)]
pub struct ModelInvocationHistoryVerifier {
last: Option<ModelInvocation>,
}
impl ModelInvocationHistoryVerifier {
#[must_use]
pub const fn new() -> Self {
Self { last: None }
}
#[must_use]
pub fn after(record: ModelInvocation) -> Self {
Self { last: Some(record) }
}
#[must_use]
pub fn head(&self) -> Option<ModelInvocationHead> {
self.last.as_ref().map(ModelInvocation::head)
}
#[must_use]
pub const fn has_records(&self) -> bool {
self.last.is_some()
}
pub fn verify_next(
&mut self,
record: &ModelInvocation,
) -> Result<(), ModelInvocationHistoryError> {
let Some(previous) = self.last.as_ref() else {
if record.revision != ModelInvocationRevision::INITIAL {
return Err(ModelInvocationHistoryError::FirstRecordNotInitial {
actual: record.revision,
});
}
self.last = Some(record.clone());
return Ok(());
};
if record.intent != previous.intent {
return Err(ModelInvocationHistoryError::IntentMismatch);
}
if record.previous.as_ref() != Some(&previous.head()) {
return Err(ModelInvocationHistoryError::PreviousHeadMismatch);
}
let transition = record
.transition
.as_ref()
.ok_or(ModelInvocationHistoryError::TransitionMissing)?;
let expected = previous
.advance(transition.clone(), record.journal_head.clone())
.map_err(|source| ModelInvocationHistoryError::Transition { source })?;
if !canonical_equal(&expected, record)
.map_err(|source| ModelInvocationHistoryError::Integrity { source })?
{
return Err(ModelInvocationHistoryError::RecordMismatch);
}
self.last = Some(record.clone());
Ok(())
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationHistoryError {
#[error("first model invocation record is revision {actual}; expected 0")]
FirstRecordNotInitial {
actual: ModelInvocationRevision,
},
#[error("model invocation history changed its immutable intent")]
IntentMismatch,
#[error("model invocation history predecessor head mismatch")]
PreviousHeadMismatch,
#[error("model invocation history successor is missing its transition")]
TransitionMissing,
#[error("model invocation history transition is invalid: {source}")]
Transition {
#[source]
source: ModelInvocationError,
},
#[error("model invocation history successor does not match the applied transition")]
RecordMismatch,
#[error("model invocation history integrity comparison failed: {source}")]
Integrity {
#[source]
source: ModelInvocationIntegrityError,
},
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationError {
#[error("model invocation integrity calculation failed: {source}")]
Integrity {
#[source]
source: ModelInvocationIntegrityError,
},
#[error("model invocation journal head crosses the tenant boundary")]
JournalTenantMismatch,
#[error("model invocation journal head does not belong to the run")]
JournalRunMismatch,
#[error("model invocation journal sequence {actual} does not advance {previous}")]
JournalDidNotAdvance {
previous: JournalSequence,
actual: JournalSequence,
},
#[error("model invocation journal clock regressed from {previous} to {actual}")]
ClockRegression {
previous: Timestamp,
actual: Timestamp,
},
#[error("model invocation revision exceeds the PostgreSQL BIGINT maximum")]
RevisionOverflow,
#[error("initial model invocation revision must be prepared with no predecessor or transition")]
InvalidInitialShape,
#[error(
"model invocation successor must contain predecessor, transition, and transition digest"
)]
InvalidSuccessorShape,
#[error("model invocation predecessor crosses the tenant boundary")]
PreviousTenantMismatch,
#[error("model invocation predecessor names another run")]
PreviousRunMismatch,
#[error("model invocation predecessor names another invocation")]
PreviousInvocationMismatch,
#[error("model invocation revision {actual} does not follow predecessor {previous}")]
PreviousRevisionMismatch {
previous: ModelInvocationRevision,
actual: ModelInvocationRevision,
},
#[error("model invocation transition digest does not match its payload")]
TransitionDigestMismatch,
#[error("model invocation transition {transition:?} is invalid from {status:?}")]
InvalidTransition {
status: ModelInvocationStatus,
transition: ModelInvocationTransitionKind,
},
#[error("model invocation transition payload does not match its resulting state")]
TransitionStateMismatch,
#[error("model invocation retry must use a new physical attempt identifier")]
ReusedAttemptId,
#[error("model invocation failure does not authorize retry")]
RetryNotAuthorized,
#[error("model invocation retry delay exceeds the supported timestamp range")]
RetryDelayOutOfRange,
#[error("model invocation retry at {actual} precedes not-before time {not_before}")]
RetryDelayNotElapsed {
not_before: Timestamp,
actual: Timestamp,
},
#[error("model response names another physical attempt")]
ResponseAttemptMismatch,
#[error("model response does not match the invocation: {source}")]
ResponseBinding {
#[source]
source: ModelResponseError,
},
#[error("model failure does not match the invocation: {source}")]
ErrorBinding {
#[source]
source: ModelErrorValidationError,
},
#[error("model preparation failure cannot contain provider usage")]
PreparationFailureHasUsage,
#[error("model invocation record digest does not match its fields")]
DigestMismatch,
}
impl From<ModelInvocationIntegrityError> for ModelInvocationError {
fn from(source: ModelInvocationIntegrityError) -> Self {
Self::Integrity { source }
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelInvocationIntegrityError {
#[error("model invocation checksum preimage canonical serialization failed")]
CanonicalSerialization,
}
#[derive(Serialize)]
struct ModelInvocationIntentDigestWire<'a> {
activation: &'a NodeActivation,
invocation_id: InvocationId,
descriptor: &'a ModelDescriptor,
request: &'a ModelRequest,
}
#[derive(Serialize)]
struct ModelInvocationRecordDigestWire<'a> {
intent_digest: Digest,
revision: ModelInvocationRevision,
state: &'a ModelInvocationState,
#[serde(skip_serializing_if = "Option::is_none")]
previous: Option<&'a ModelInvocationHead>,
journal_head: &'a JournalHead,
#[serde(skip_serializing_if = "Option::is_none")]
transition_digest: Option<Digest>,
}
fn compute_intent_digest(
value: &ModelInvocationIntentDigestWire<'_>,
) -> Result<Digest, ModelInvocationIntegrityError> {
domain_separated_digest(INTENT_DIGEST_DOMAIN, value)
}
fn compute_transition_digest(
value: &ModelInvocationTransition,
) -> Result<Digest, ModelInvocationIntegrityError> {
domain_separated_digest(TRANSITION_DIGEST_DOMAIN, value)
}
fn compute_record_digest(
value: &ModelInvocationRecordDigestWire<'_>,
) -> Result<Digest, ModelInvocationIntegrityError> {
domain_separated_digest(RECORD_DIGEST_DOMAIN, value)
}
fn domain_separated_digest<T: Serialize>(
domain: &[u8],
value: &T,
) -> Result<Digest, ModelInvocationIntegrityError> {
let canonical = serde_json_canonicalizer::to_vec(value)
.map_err(|_| ModelInvocationIntegrityError::CanonicalSerialization)?;
let mut preimage = Vec::with_capacity(domain.len() + canonical.len());
preimage.extend_from_slice(domain);
preimage.extend_from_slice(&canonical);
Ok(Digest::sha256(preimage))
}
fn canonical_equal<T: Serialize>(
left: &T,
right: &T,
) -> Result<bool, ModelInvocationIntegrityError> {
let left = serde_json_canonicalizer::to_vec(left)
.map_err(|_| ModelInvocationIntegrityError::CanonicalSerialization)?;
let right = serde_json_canonicalizer::to_vec(right)
.map_err(|_| ModelInvocationIntegrityError::CanonicalSerialization)?;
Ok(left == right)
}
fn validate_intent_shape(
descriptor: &ModelDescriptor,
request: &ModelRequest,
) -> Result<(), ModelInvocationIntentError> {
if descriptor.metadata().lifecycle().state() == CapabilityLifecycleState::Retired {
return Err(ModelInvocationIntentError::RetiredModel);
}
descriptor
.capabilities()
.satisfies(request.requirements())
.map_err(|mismatch| ModelInvocationIntentError::CapabilityMismatch {
mismatch: Box::new(mismatch),
})
}
#[derive(Clone, Copy)]
enum InvocationScopeError {
Tenant,
Run,
}
fn validate_journal_scope(
tenant_id: &TenantId,
run_id: RunId,
head: &JournalHead,
) -> Result<(), InvocationScopeError> {
if head.tenant_id() != tenant_id {
return Err(InvocationScopeError::Tenant);
}
if head.run_id() != run_id {
return Err(InvocationScopeError::Run);
}
Ok(())
}
fn validate_status_attempt(
status: ModelInvocationStatus,
attempt_id: Option<AttemptId>,
) -> Result<(), ModelInvocationHeadError> {
match (status, attempt_id) {
(ModelInvocationStatus::Prepared, None)
| (
ModelInvocationStatus::Executing
| ModelInvocationStatus::Committed
| ModelInvocationStatus::Failed,
Some(_),
) => Ok(()),
(ModelInvocationStatus::Prepared, Some(_)) => {
Err(ModelInvocationHeadError::PreparedHasAttempt)
}
(
ModelInvocationStatus::Executing
| ModelInvocationStatus::Committed
| ModelInvocationStatus::Failed,
None,
) => Err(ModelInvocationHeadError::AttemptMissing),
}
}
fn validate_revision_status(
revision: ModelInvocationRevision,
status: ModelInvocationStatus,
) -> Result<(), ModelInvocationHeadError> {
match (revision == ModelInvocationRevision::INITIAL, status) {
(true, ModelInvocationStatus::Prepared)
| (
false,
ModelInvocationStatus::Executing
| ModelInvocationStatus::Committed
| ModelInvocationStatus::Failed,
) => Ok(()),
(true, _) => Err(ModelInvocationHeadError::InitialStatusMismatch),
(false, ModelInvocationStatus::Prepared) => {
Err(ModelInvocationHeadError::PreparedRevisionMismatch)
}
}
}
fn map_scope_error(error: InvocationScopeError) -> ModelInvocationError {
match error {
InvocationScopeError::Tenant => ModelInvocationError::JournalTenantMismatch,
InvocationScopeError::Run => ModelInvocationError::JournalRunMismatch,
}
}
fn validate_journal_advances(
previous: &JournalHead,
actual: &JournalHead,
) -> Result<(), ModelInvocationError> {
if actual.sequence() <= previous.sequence() {
return Err(ModelInvocationError::JournalDidNotAdvance {
previous: previous.sequence(),
actual: actual.sequence(),
});
}
if actual.recorded_at() < previous.recorded_at() {
return Err(ModelInvocationError::ClockRegression {
previous: previous.recorded_at(),
actual: actual.recorded_at(),
});
}
Ok(())
}
fn validate_preparation_journal(
intent: &ModelInvocationIntent,
journal_head: &JournalHead,
) -> Result<(), ModelInvocationError> {
validate_journal_scope(intent.tenant_id(), intent.run_id(), journal_head)
.map_err(map_scope_error)?;
validate_journal_advances(
intent.activation.base_checkpoint().journal_head(),
journal_head,
)
}
fn validate_successor_journal(
invocation: &ModelInvocation,
journal_head: &JournalHead,
) -> Result<(), ModelInvocationError> {
validate_journal_scope(
invocation.intent.tenant_id(),
invocation.intent.run_id(),
journal_head,
)
.map_err(map_scope_error)?;
validate_journal_advances(&invocation.journal_head, journal_head)
}
#[allow(clippy::too_many_arguments)]
fn validate_record_shape(
intent: &ModelInvocationIntent,
revision: ModelInvocationRevision,
state: &ModelInvocationState,
previous: Option<&ModelInvocationHead>,
journal_head: &JournalHead,
transition: Option<&ModelInvocationTransition>,
transition_digest: Option<Digest>,
) -> Result<(), ModelInvocationError> {
validate_journal_scope(intent.tenant_id(), intent.run_id(), journal_head)
.map_err(map_scope_error)?;
validate_state_binding(intent, state)?;
if revision == ModelInvocationRevision::INITIAL {
if !matches!(state, ModelInvocationState::Prepared)
|| previous.is_some()
|| transition.is_some()
|| transition_digest.is_some()
{
return Err(ModelInvocationError::InvalidInitialShape);
}
return validate_preparation_journal(intent, journal_head);
}
let (Some(previous), Some(transition), Some(transition_digest)) =
(previous, transition, transition_digest)
else {
return Err(ModelInvocationError::InvalidSuccessorShape);
};
if previous.tenant_id() != intent.tenant_id() {
return Err(ModelInvocationError::PreviousTenantMismatch);
}
if previous.run_id() != intent.run_id() {
return Err(ModelInvocationError::PreviousRunMismatch);
}
if previous.invocation_id() != intent.invocation_id() {
return Err(ModelInvocationError::PreviousInvocationMismatch);
}
if previous.revision().checked_next() != Some(revision) {
return Err(ModelInvocationError::PreviousRevisionMismatch {
previous: previous.revision(),
actual: revision,
});
}
validate_journal_advances(previous.journal_head(), journal_head)?;
if compute_transition_digest(transition)? != transition_digest {
return Err(ModelInvocationError::TransitionDigestMismatch);
}
validate_transition_shape(intent, previous, transition, state)
}
fn validate_state_binding(
intent: &ModelInvocationIntent,
state: &ModelInvocationState,
) -> Result<(), ModelInvocationError> {
match state {
ModelInvocationState::Prepared | ModelInvocationState::Executing { .. } => Ok(()),
ModelInvocationState::Committed { response } => {
validate_response_binding(intent, response.provenance().attempt_id(), response)
}
ModelInvocationState::Failed { error } => {
validate_error_binding(intent, error.provenance().attempt_id(), error)
}
}
}
fn validate_response_binding(
intent: &ModelInvocationIntent,
expected_attempt: AttemptId,
response: &ModelResponse,
) -> Result<(), ModelInvocationError> {
if response.provenance().attempt_id() != expected_attempt {
return Err(ModelInvocationError::ResponseAttemptMismatch);
}
response
.validate_for(&intent.descriptor, &intent.request)
.map_err(|source| ModelInvocationError::ResponseBinding { source })
}
fn validate_error_binding(
intent: &ModelInvocationIntent,
expected_attempt: AttemptId,
error: &ModelError,
) -> Result<(), ModelInvocationError> {
error
.validate_for_attempt(expected_attempt, &intent.descriptor, &intent.request)
.map_err(|source| ModelInvocationError::ErrorBinding { source })?;
if error.phase() == ModelErrorPhase::Preparation && error.usage().is_some() {
return Err(ModelInvocationError::PreparationFailureHasUsage);
}
Ok(())
}
fn validate_transition_shape(
intent: &ModelInvocationIntent,
previous: &ModelInvocationHead,
transition: &ModelInvocationTransition,
state: &ModelInvocationState,
) -> Result<(), ModelInvocationError> {
let valid = match (previous.status(), transition, state) {
(
ModelInvocationStatus::Prepared | ModelInvocationStatus::Failed,
ModelInvocationTransition::StartAttempt { attempt_id },
ModelInvocationState::Executing {
attempt_id: state_attempt,
},
) => {
if previous.attempt_id() == Some(*attempt_id) {
return Err(ModelInvocationError::ReusedAttemptId);
}
attempt_id == state_attempt
}
(
ModelInvocationStatus::Executing,
ModelInvocationTransition::RecordResponse { response },
ModelInvocationState::Committed {
response: state_response,
},
) => canonical_equal(response, state_response)?,
(
ModelInvocationStatus::Executing,
ModelInvocationTransition::RecordError { error },
ModelInvocationState::Failed { error: state_error },
) => canonical_equal(error, state_error)?,
_ => {
return Err(ModelInvocationError::InvalidTransition {
status: previous.status(),
transition: transition.kind(),
});
}
};
if !valid {
return Err(ModelInvocationError::TransitionStateMismatch);
}
let expected_attempt = previous.attempt_id();
match transition {
ModelInvocationTransition::StartAttempt { .. } => {}
ModelInvocationTransition::RecordResponse { response } => {
validate_response_binding(
intent,
expected_attempt.ok_or(ModelInvocationError::TransitionStateMismatch)?,
response,
)?;
}
ModelInvocationTransition::RecordError { error } => {
validate_error_binding(
intent,
expected_attempt.ok_or(ModelInvocationError::TransitionStateMismatch)?,
error,
)?;
}
}
Ok(())
}
fn apply_transition(
invocation: &ModelInvocation,
transition: &ModelInvocationTransition,
recorded_at: Timestamp,
) -> Result<ModelInvocationState, ModelInvocationError> {
match (&invocation.state, transition) {
(
ModelInvocationState::Prepared,
ModelInvocationTransition::StartAttempt { attempt_id },
) => Ok(ModelInvocationState::Executing {
attempt_id: *attempt_id,
}),
(
ModelInvocationState::Failed { error },
ModelInvocationTransition::StartAttempt { attempt_id },
) => {
let previous_attempt = error.provenance().attempt_id();
if previous_attempt == *attempt_id {
return Err(ModelInvocationError::ReusedAttemptId);
}
validate_retry(invocation, error, recorded_at)?;
Ok(ModelInvocationState::Executing {
attempt_id: *attempt_id,
})
}
(
ModelInvocationState::Executing { attempt_id },
ModelInvocationTransition::RecordResponse { response },
) => {
validate_response_binding(&invocation.intent, *attempt_id, response)?;
Ok(ModelInvocationState::Committed {
response: response.clone(),
})
}
(
ModelInvocationState::Executing { attempt_id },
ModelInvocationTransition::RecordError { error },
) => {
validate_error_binding(&invocation.intent, *attempt_id, error)?;
Ok(ModelInvocationState::Failed {
error: error.clone(),
})
}
_ => Err(ModelInvocationError::InvalidTransition {
status: invocation.status(),
transition: transition.kind(),
}),
}
}
fn validate_retry(
invocation: &ModelInvocation,
error: &ModelError,
recorded_at: Timestamp,
) -> Result<(), ModelInvocationError> {
let Some(delay) = error.failure().retry_advice().safe_after_delay() else {
return Err(ModelInvocationError::RetryNotAuthorized);
};
let not_before_micros = i128::from(invocation.journal_head.recorded_at().unix_micros())
+ i128::from(delay.as_i64()) * 1_000;
if not_before_micros > i128::from(Timestamp::MAX.unix_micros()) {
return Err(ModelInvocationError::RetryDelayOutOfRange);
}
let not_before = Timestamp::from_unix_micros(
i64::try_from(not_before_micros).map_err(|_| ModelInvocationError::RetryDelayOutOfRange)?,
)
.map_err(|_| ModelInvocationError::RetryDelayOutOfRange)?;
if recorded_at < not_before {
return Err(ModelInvocationError::RetryDelayNotElapsed {
not_before,
actual: recorded_at,
});
}
Ok(())
}
#[cfg(test)]
mod tests {
use schemars::schema_for;
use serde_json::{Value, from_value, json, to_value};
use super::*;
use crate::{
Checkpoint, DurationMillis, EventId, Failure, FailureCategory, FailureCode, FailureId,
FailureMessage, FailureOrigin, GraphNamespace, ModelErrorProvenance, ModelUsage, NodeId,
RetryAdvice,
};
fn fixture(path: &[&str], source: &str) -> Value {
let mut value: Value = serde_json::from_str(source).unwrap();
for component in path {
value = match component.parse::<usize>() {
Ok(index) => value[index].clone(),
Err(_) => value[*component].clone(),
};
}
value
}
fn checkpoint() -> Checkpoint {
from_value(fixture(
&["checkpoints", "0"],
include_str!("../tests/fixtures/core-checkpoint-v1.json"),
))
.unwrap()
}
fn descriptor() -> ModelDescriptor {
from_value(fixture(
&["descriptors", "valid", "0", "model"],
include_str!("../tests/fixtures/core-agent-v1.json"),
))
.unwrap()
}
fn request() -> ModelRequest {
from_value(fixture(
&["requests", "valid", "0"],
include_str!("../tests/fixtures/core-model-request-v1.json"),
))
.unwrap()
}
fn invocation_id() -> InvocationId {
"01912345-6789-7abc-8def-0123456789d0".parse().unwrap()
}
fn attempt(suffix: &str) -> AttemptId {
format!("01912345-6789-7abc-8def-0123456789{suffix}")
.parse()
.unwrap()
}
fn intent() -> ModelInvocationIntent {
let checkpoint = checkpoint();
ModelInvocationIntent::new(
NodeActivation::new(
checkpoint.head(),
GraphNamespace::root(),
NodeId::new("reason").unwrap(),
Digest::sha256(b"model-node-input"),
),
invocation_id(),
descriptor(),
request(),
)
.unwrap()
}
fn journal(intent: &ModelInvocationIntent, sequence: u64) -> JournalHead {
let base = intent
.activation()
.base_checkpoint()
.journal_head()
.recorded_at();
let offset = i64::try_from(sequence - 1).unwrap() * 1_000_000;
journal_at(
intent,
sequence,
Timestamp::from_unix_micros(base.unix_micros() + offset).unwrap(),
)
}
fn journal_at(
intent: &ModelInvocationIntent,
sequence: u64,
recorded_at: Timestamp,
) -> JournalHead {
let event_id: EventId =
format!("01912345-6789-7abc-8def-0123456789{:02x}", 0xd0 + sequence)
.parse()
.unwrap();
JournalHead::new(
intent.tenant_id().clone(),
intent.run_id(),
JournalSequence::new(sequence).unwrap(),
event_id,
recorded_at,
Digest::sha256(sequence.to_be_bytes()),
)
}
fn response(attempt_id: AttemptId) -> ModelResponse {
let descriptor = descriptor();
let request = request();
let mut value = fixture(
&["responses", "valid", "0"],
include_str!("../tests/fixtures/core-model-response-v1.json"),
);
value["provenance"]["attempt_id"] = json!(attempt_id);
value["provenance"]["model"] = to_value(descriptor.metadata().identity()).unwrap();
let response = from_value::<ModelResponse>(value).unwrap();
response.validate_for(&descriptor, &request).unwrap();
response
}
fn model_error(
attempt_id: AttemptId,
phase: ModelErrorPhase,
retry_advice: RetryAdvice,
usage: Option<ModelUsage>,
) -> ModelError {
let descriptor = descriptor();
let failure = Failure::new(
"01912345-6789-7abc-8def-0123456789b8"
.parse::<FailureId>()
.unwrap(),
FailureCategory::DependencyUnavailable,
FailureCode::new("model.dependency_unavailable").unwrap(),
FailureOrigin::new("model.provider").unwrap(),
FailureMessage::new("The model provider is temporarily unavailable.").unwrap(),
retry_advice,
)
.unwrap();
ModelError::new(
failure,
phase,
ModelErrorProvenance::new(
attempt_id,
descriptor.metadata().identity().clone(),
None,
None,
None,
),
usage,
)
}
fn prepared() -> ModelInvocation {
let intent = intent();
let head = journal(&intent, 2);
ModelInvocation::prepare(intent, head).unwrap()
}
#[test]
fn revision_and_intent_wires_are_canonical_negotiated_and_bound() {
for value in [0, 1, i64::MAX as u64] {
let revision = ModelInvocationRevision::new(value).unwrap();
assert_eq!(to_value(revision).unwrap(), json!(value.to_string()));
assert_eq!(
from_value::<ModelInvocationRevision>(json!(value.to_string())).unwrap(),
revision
);
}
for invalid in [
json!(""),
json!("01"),
json!("9223372036854775808"),
json!(1),
] {
assert!(from_value::<ModelInvocationRevision>(invalid).is_err());
}
let intent = intent();
let wire = to_value(&intent).unwrap();
assert_eq!(
from_value::<ModelInvocationIntent>(wire.clone()).unwrap(),
intent
);
let mut tampered = wire;
tampered["request"]["instructions"][0]["content"]["content"]["text"] =
json!("changed prompt");
assert!(from_value::<ModelInvocationIntent>(tampered).is_err());
let mut excessive = to_value(request()).unwrap();
excessive["limits"]["max_output_tokens"] = json!("20000");
excessive["requirements"]["min_output_tokens"] = json!("20000");
excessive["requirements"]["min_context_tokens"] = json!("28192");
let excessive = from_value::<ModelRequest>(excessive).unwrap();
assert!(matches!(
ModelInvocationIntent::new(
intent.activation().clone(),
InvocationId::generate(),
descriptor(),
excessive,
),
Err(ModelInvocationIntentError::CapabilityMismatch { .. })
));
let mut retired = to_value(descriptor()).unwrap();
retired["metadata"]["lifecycle"] = json!({
"status": "retired",
"retired_at": "2027-02-28T00:00:00.000001Z",
"notice": "This binding is retained only for durable history."
});
let retired = from_value::<ModelDescriptor>(retired).unwrap();
assert_eq!(
ModelInvocationIntent::new(
intent.activation().clone(),
InvocationId::generate(),
retired,
request(),
),
Err(ModelInvocationIntentError::RetiredModel)
);
}
#[test]
fn prepared_attempt_and_response_form_one_verified_terminal_history() {
let prepared = prepared();
let attempt_id = attempt("ab");
let executing = prepared
.advance(
ModelInvocationTransition::StartAttempt { attempt_id },
journal(prepared.intent(), 3),
)
.unwrap();
let committed = executing
.advance(
ModelInvocationTransition::RecordResponse {
response: response(attempt_id),
},
journal(executing.intent(), 4),
)
.unwrap();
assert_eq!(prepared.status(), ModelInvocationStatus::Prepared);
assert_eq!(executing.status(), ModelInvocationStatus::Executing);
assert_eq!(committed.status(), ModelInvocationStatus::Committed);
assert_eq!(committed.attempt_id(), Some(attempt_id));
assert!(matches!(
committed.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: attempt("ac"),
},
journal(committed.intent(), 5),
),
Err(ModelInvocationError::InvalidTransition { .. })
));
let restored = from_value::<ModelInvocation>(to_value(&committed).unwrap()).unwrap();
assert_eq!(to_value(restored).unwrap(), to_value(&committed).unwrap());
let mut verifier = ModelInvocationHistoryVerifier::new();
for record in [&prepared, &executing, &committed] {
verifier.verify_next(record).unwrap();
}
assert_eq!(verifier.head(), Some(committed.head()));
}
#[test]
fn failed_attempt_retry_requires_new_identity_explicit_advice_and_durable_delay() {
let prepared = prepared();
let first_attempt = attempt("ab");
let executing = prepared
.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: first_attempt,
},
journal(prepared.intent(), 3),
)
.unwrap();
let failed = executing
.advance(
ModelInvocationTransition::RecordError {
error: model_error(
first_attempt,
ModelErrorPhase::Dispatch,
RetryAdvice::SafeAfter {
delay: DurationMillis::new(1_000).unwrap(),
},
None,
),
},
journal(executing.intent(), 4),
)
.unwrap();
assert!(matches!(
failed.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: first_attempt,
},
journal(failed.intent(), 5),
),
Err(ModelInvocationError::ReusedAttemptId)
));
let too_early = journal_at(
failed.intent(),
5,
Timestamp::from_unix_micros(
failed.journal_head().recorded_at().unix_micros() + 999_999,
)
.unwrap(),
);
assert!(matches!(
failed.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: attempt("ac"),
},
too_early,
),
Err(ModelInvocationError::RetryDelayNotElapsed { .. })
));
let retried = failed
.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: attempt("ac"),
},
journal(failed.intent(), 5),
)
.unwrap();
assert_eq!(retried.status(), ModelInvocationStatus::Executing);
let never_executing = prepared
.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: attempt("ad"),
},
journal(prepared.intent(), 3),
)
.unwrap();
let never_failed = never_executing
.advance(
ModelInvocationTransition::RecordError {
error: model_error(
attempt("ad"),
ModelErrorPhase::Preparation,
RetryAdvice::Never,
None,
),
},
journal(never_executing.intent(), 4),
)
.unwrap();
assert!(matches!(
never_failed.advance(
ModelInvocationTransition::StartAttempt {
attempt_id: attempt("ae"),
},
journal(never_failed.intent(), 5),
),
Err(ModelInvocationError::RetryNotAuthorized)
));
}
#[test]
fn attempt_result_error_and_integrity_substitution_fail_closed() {
let prepared = prepared();
let attempt_id = attempt("ab");
let executing = prepared
.advance(
ModelInvocationTransition::StartAttempt { attempt_id },
journal(prepared.intent(), 3),
)
.unwrap();
assert!(matches!(
executing.advance(
ModelInvocationTransition::RecordResponse {
response: response(attempt("ac")),
},
journal(executing.intent(), 4),
),
Err(ModelInvocationError::ResponseAttemptMismatch)
));
assert!(matches!(
executing.advance(
ModelInvocationTransition::RecordError {
error: model_error(
attempt("ac"),
ModelErrorPhase::Dispatch,
RetryAdvice::Never,
None,
),
},
journal(executing.intent(), 4),
),
Err(ModelInvocationError::ErrorBinding {
source: ModelErrorValidationError::AttemptMismatch { .. }
})
));
assert!(matches!(
executing.advance(
ModelInvocationTransition::RecordError {
error: model_error(
attempt_id,
ModelErrorPhase::Preparation,
RetryAdvice::Never,
Some(response(attempt_id).usage().clone()),
),
},
journal(executing.intent(), 4),
),
Err(ModelInvocationError::PreparationFailureHasUsage)
));
let mut wire = to_value(&executing).unwrap();
wire["state"]["attempt_id"] = json!(attempt("ac"));
assert!(from_value::<ModelInvocation>(wire).is_err());
let mut wire = to_value(&executing).unwrap();
wire["transition"]["attempt_id"] = json!(attempt("ac"));
assert!(from_value::<ModelInvocation>(wire).is_err());
let mut verifier = ModelInvocationHistoryVerifier::new();
assert!(matches!(
verifier.verify_next(&executing),
Err(ModelInvocationHistoryError::FirstRecordNotInitial { .. })
));
assert!(!verifier.has_records());
}
#[test]
fn public_model_invocation_schemas_are_closed() {
for schema in [
to_value(schema_for!(ModelInvocationIntent)).unwrap(),
to_value(schema_for!(ModelInvocationHead)).unwrap(),
to_value(schema_for!(ModelInvocation)).unwrap(),
] {
assert_eq!(schema["additionalProperties"], Value::Bool(false));
}
}
}