Struct OrchestratorConfig 

#[non_exhaustive]
pub struct OrchestratorConfig {
    pub mode: OrchestrationMode,
    pub understanding: UnderstandingConfig,
    pub attachments: AttachmentConfig,
    pub narration: NarrationConfig,
    pub interaction: InteractionConfig,
    pub execution: ExecutionConfig,
    pub observability: ObservabilityConfig,
    pub privacy: PrivacyConfig,
    pub effort: EffortConfig,
}

Everything the runtime needs to know before it handles a turn (Appendix A).

Provider routing is deliberately absent: it belongs to the provider layer and this crate depends on turnframe-core alone.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

mode: OrchestrationMode

How much autonomy the model gets.

understanding: UnderstandingConfig

How the turn is understood.

attachments: AttachmentConfig

How much of the turn’s files reaches a model.

narration: NarrationConfig

How the assistant talks.

interaction: InteractionConfig

How cards behave.

execution: ExecutionConfig

How commands execute.

observability: ObservabilityConfig

What is measured and recorded.

privacy: PrivacyConfig

What may leave the runtime.

effort: EffortConfig

The default effort, and what each level changes.

Implementations

impl OrchestratorConfig

pub const fn conservative() -> Self

Every section at its conservative default, in OrchestrationMode::Deterministic.

pub fn with_effort(self, effort: EffortConfig) -> Self

Returns a copy with another default effort and other level changes.

pub const fn with_attachments(self, attachments: AttachmentConfig) -> Self

Returns a copy with another attachment budget.

pub fn with_mode(self, mode: OrchestrationMode) -> Self

Returns a copy in another orchestration mode.

pub fn with_understanding(self, understanding: UnderstandingConfig) -> Self

Returns a copy with another understanding section.

pub const fn with_narration(self, narration: NarrationConfig) -> Self

Returns a copy with another narration section.

pub const fn with_interaction(self, interaction: InteractionConfig) -> Self

Returns a copy with another interaction section.

pub const fn with_execution(self, execution: ExecutionConfig) -> Self

Returns a copy with another execution section.

pub const fn with_observability( self, observability: ObservabilityConfig, ) -> Self

Returns a copy with another observability section.

pub const fn with_privacy(self, privacy: PrivacyConfig) -> Self

Returns a copy with another privacy section.

pub fn policy_snapshot(&self, base: PolicySnapshot) -> PolicySnapshot

Tightens base with the risk classes the mode refuses (§11.4).

The result only ever forbids more than base did: a mode cannot widen a policy snapshot, and origin_satisfies keeps its own floor regardless of either.

pub fn validate(&self) -> Result<(), ConfigError>

Checks every section and the rules that span sections.

Cross-section rules:

• storing model prompts while the replay record is switched off asks for prompts nothing will ever write;
• sandboxed autonomy without a replay record leaves the one mode where the model drives writes with no way to explain what it did (I20).

Trait Implementations

impl Clone for OrchestratorConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrchestratorConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OrchestratorConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OrchestratorConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OrchestratorConfig

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for OrchestratorConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OrchestratorConfig