reasoninglayer 0.2.1

//! Cognitive-agent DTOs (BDI agents, perceive-reason-act cycle, integrated 9-module
//! architecture, plans/HTN/messaging/episodes/feedback).

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentConfigDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_goals_per_cycle: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub belief_confidence_threshold: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable_learning: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_belief_history: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateAgentRequest {
    pub name: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<AgentConfigDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateAgentResponse {
    pub agent_id: String,
    pub name: String,
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GoalDto {
    /// Sort name (alias `sort_name` accepted by backend).
    #[serde(alias = "sort_name")]
    pub sort: String,
    /// Optional sort UUID; takes precedence over `sort` when present.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sort_id: Option<String>,
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddGoalRequest {
    pub agent_id: String,
    pub tenant_id: String,
    pub goal: GoalDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<i32>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddGoalResponse {
    pub goal_id: String,
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BeliefDto {
    pub sort: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sort_id: Option<String>,
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddBeliefRequest {
    pub agent_id: String,
    pub tenant_id: String,
    pub belief: BeliefDto,
    pub confidence: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddBeliefResponse {
    pub belief_id: String,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RunCycleRequest {
    pub agent_id: String,
    pub tenant_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CycleOutcomeDto {
    #[serde(default)]
    pub goals_pursued: Vec<String>,
    #[serde(default)]
    pub goals_achieved: Vec<String>,
    #[serde(default)]
    pub goals_failed: Vec<String>,
    #[serde(default)]
    pub new_beliefs: Vec<String>,
    #[serde(default)]
    pub updated_beliefs: Vec<String>,
    #[serde(default)]
    pub actions_executed: Vec<String>,
    pub success_rate: f64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RunCycleResponse {
    pub outcome: CycleOutcomeDto,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GetAgentStateRequest {
    pub agent_id: String,
    pub tenant_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentGoalDto {
    pub goal_id: String,
    pub sort_name: String,
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentBeliefDto {
    pub belief_id: String,
    pub sort_name: String,
    #[serde(default)]
    pub features: BTreeMap<String, serde_json::Value>,
    pub confidence: f64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentStateDto {
    #[serde(default)]
    pub goals: Vec<AgentGoalDto>,
    #[serde(default)]
    pub beliefs: Vec<AgentBeliefDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetAgentStateResponse {
    pub state: AgentStateDto,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReflectionQueryRequest {
    pub agent_id: String,
    pub tenant_id: String,
    pub query: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReflectionQueryResponse {
    #[serde(default)]
    pub matches: Vec<String>,
    pub message: String,
}

/// Free-form rule-modification record (backend uses an internal struct that's
/// still in flux).
pub type RuleModDto = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdaptiveModifyRequest {
    pub agent_id: String,
    pub tenant_id: String,
    pub modifications: Vec<RuleModDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AdaptiveModifyResponse {
    #[serde(default)]
    pub modified_rule_ids: Vec<String>,
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct IntegratedEngineConfigDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attention_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable_prediction_learning: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable_utility_learning: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub impasse_threshold: Option<f64>,
    /// Catch-all for the remaining 9-module configuration knobs.
    #[serde(default, flatten)]
    pub extra: BTreeMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RunIntegratedCycleRequest {
    pub agent_id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<IntegratedEngineConfigDto>,
}

pub type IntentionDto = serde_json::Value;
pub type ImpasseDto = serde_json::Value;
pub type PredictionErrorDto = serde_json::Value;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct IntegratedCycleOutcomeDto {
    #[serde(default)]
    pub intentions: Vec<IntentionDto>,
    #[serde(default)]
    pub impasses: Vec<ImpasseDto>,
    #[serde(default)]
    pub prediction_errors: Vec<PredictionErrorDto>,
    #[serde(default)]
    pub activated_rules: Vec<String>,
    #[serde(default)]
    pub executed_actions: Vec<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RunIntegratedCycleResponse {
    pub outcome: IntegratedCycleOutcomeDto,
    pub message: String,
}

pub type ActivationDto = serde_json::Value;
pub type EpisodeDto = serde_json::Value;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ExtendedAgentStateResponse {
    #[serde(default)]
    pub goals: Vec<AgentGoalDto>,
    #[serde(default)]
    pub beliefs: Vec<AgentBeliefDto>,
    #[serde(default)]
    pub activations: Vec<ActivationDto>,
    #[serde(default)]
    pub episodes: Vec<EpisodeDto>,
    pub message: String,
}