Struct FocusDecision 

pub struct FocusDecision {
    pub selected_focus_id: Option<String>,
    pub need_new_focus: bool,
    pub new_focus_topic: Option<String>,
    pub new_core_question: Option<String>,
    pub confidence: f32,
    pub focus_type: FocusType,
    pub is_topic_switch: bool,
    pub previous_focus_id: Option<String>,
    pub focus_keywords: Vec<String>,
    pub related_entities: Vec<String>,
    pub reasoning: String,
}

AI focus decision - the AI’s judgment on current conversation focus.

Instead of extracting focus from scratch, the AI selects from existing focuses or decides to create a new one. This ensures focus continuity and proper history tracking.

Fields

selected_focus_id: Option<String>

ID of the selected existing focus (if matched). None if need_new_focus is true.

need_new_focus: bool

Whether none of the existing focuses match and a new focus is needed.

new_focus_topic: Option<String>

New focus topic (only if need_new_focus is true).

new_core_question: Option<String>

Core question/task for the new focus.

confidence: f32

Confidence of the selection/creation (0.0-1.0).

focus_type: FocusType

Focus type classification.

is_topic_switch: bool

Whether this is a topic switch from a previous focus.

previous_focus_id: Option<String>

The previous focus being switched from (if is_topic_switch).

focus_keywords: Vec<String>

Core keywords for this focus (3-5 keywords).

related_entities: Vec<String>

Related entities (files, functions, modules).

reasoning: String

AI’s reasoning for this decision.

Trait Implementations

impl Clone for FocusDecision

fn clone(&self) -> FocusDecision

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FocusDecision

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FocusDecision

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FocusDecision

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

where __S: Serializer,

Serialize this value into the given Serde serializer.