Struct ConsultationInput 

pub struct ConsultationInput {

    pub plan: String,
    pub advisor: String,
    pub status: ConsultationStatus,
    pub question: Option<String>,
    pub evidence: Vec<ReasoningEvidence>,
    pub conclusion: Option<String>,
    pub stance: Option<Stance>,
    pub assumptions: Vec<String>,
    pub risks: Vec<String>,
    pub actions: Vec<String>,
    pub falsifiers: Vec<String>,
    pub confidence: Option<ReasoningConfidence>,
    pub duration_ms: Option<u64>,
    pub usage: Option<AdvisorUsage>,
    pub diagnostic: Option<String>,
    pub retry_after_seconds: Option<u64>,
}

One normalised advisor exchange: what was asked, how it ended, and what came back.

The store admits it only when the plan it names selected this advisor. A completed consultation carries a conclusion and a stance; a failed one carries neither, only its status and the adapter’s diagnostic. The full prompt and answer are never kept.

use majordomus_cli::reasoning::record::{ConsultationInput, ConsultationStatus};

let c: ConsultationInput = serde_json::from_value(serde_json::json!({
    "plan": "plan-1",
    "advisor": "alpha",
    "status": "timeout",
    "diagnostic": "timeout: no answer in 60s",
}))
.unwrap();
assert_eq!(c.status, ConsultationStatus::Timeout);
assert!(c.conclusion.is_none() && c.stance.is_none());

Fields

plan: String

The recorded plan that selected this advisor.

advisor: String

The advisor asked.

status: ConsultationStatus

How it ended.

question: Option<String>

The question asked, in one line (the full prompt is not kept).

evidence: Vec<ReasoningEvidence>

The evidence the question carried.

conclusion: Option<String>

The advisor’s conclusion, summarised. Required when completed, refused otherwise.

stance: Option<Stance>

Where it stands relative to the hypothesis.

assumptions: Vec<String>

Assumptions it identified.

risks: Vec<String>

Risks it identified.

actions: Vec<String>

Actions it recommended.

falsifiers: Vec<String>

What would falsify its conclusion.

confidence: Option<ReasoningConfidence>

Its stated confidence.

duration_ms: Option<u64>

How long it took, milliseconds.

usage: Option<AdvisorUsage>

What the transport reported it cost.

diagnostic: Option<String>

The adapter’s diagnostic for a failure: a class and a sentence, never a payload.

retry_after_seconds: Option<u64>

A rate limit’s retry-after, seconds.

Trait Implementations

impl Clone for ConsultationInput

fn clone(&self) -> ConsultationInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConsultationInput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConsultationInput

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ConsultationInput

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for ConsultationInput

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

where __S: Serializer,

Serialize this value into the given Serde serializer.