package structuredoutput import ( "errors" "gitea.maximumdirect.net/eric/audita/v3/internal/framework/outcomes" ) // FailureKind separates invalid generated content from operational failures. type FailureKind string const ( FailureMalformedOutput FailureKind = "malformed_output" FailureRuntime FailureKind = "runtime" ) // Failure exposes an operator-facing message and retains the typed cause. type Failure struct { Class FailureClass Reason outcomes.ReasonCode Message string Cause error } // FailureClass determines whether domain processing may safely skip a model // operation or must stop the run. Parent cancellation always stops the run. type FailureClass = outcomes.FailureClass const ( FailureRecoverable = outcomes.FailureRecoverable FailureFatal = outcomes.FailureFatal FailureCanceled = outcomes.FailureCanceled ) func (f *Failure) Error() string { return f.Message } func (f *Failure) Unwrap() error { return f.Cause } // EffectiveReason supplies the report reason even when a caller omitted it. func (f *Failure) EffectiveReason() outcomes.ReasonCode { if f.Reason != "" { return f.Reason } return outcomes.ReasonInternalFailure } func IsRecoverable(err error) bool { var failure *Failure return errors.As(err, &failure) && failure.Class == FailureRecoverable } // RecordFailure retains the error chain for processing and sets the compact // reason used by reports. An absent reason does not change recoverability. func RecordFailure(operation *outcomes.Operation, err error) { operation.Cause = err operation.FailureClass = FailureFatal operation.FailureReason = outcomes.ReasonInternalFailure var failure *Failure if errors.As(err, &failure) { operation.FailureClass = failure.Class operation.FailureReason = failure.EffectiveReason() } } func IsMalformedError(err error) bool { var failure *Failure return errors.As(err, &failure) && failure.Reason == outcomes.ReasonInvalidOutputExhausted }