car-ir 0.47.0

//! Core IR action types — the contract between models and the runtime.

use crate::reversibility::{Compensation, Reversibility};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use uuid::Uuid;

/// What kind of action this is.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ActionType {
    ToolCall,
    StateWrite,
    StateRead,
    Assertion,
}

/// What to do when an action fails.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum FailureBehavior {
    #[default]
    Abort,
    Retry,
    Skip,
}

/// Lifecycle status of an action.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ActionStatus {
    Proposed,
    Validated,
    Rejected,
    Executing,
    Succeeded,
    Failed,
    Skipped,
}

/// A condition that must hold before an action can execute.
///
/// Valid operators: `eq`, `neq`, `exists`, `not_exists`, `gt`, `lt`, `gte`, `lte`, `contains`.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Precondition {
    pub key: String,
    /// Comparison operator. One of: eq, neq, exists, not_exists, gt, lt, gte, lte, contains.
    #[serde(default = "default_operator")]
    pub operator: String,
    #[serde(default)]
    pub value: Value,
    #[serde(default)]
    pub description: String,
}

fn default_operator() -> String {
    "eq".to_string()
}

/// Generate a short unique ID (12 hex chars from UUIDv4).
fn short_id() -> String {
    Uuid::new_v4().simple().to_string()[..12].to_string()
}

/// A single unit of agent intent compiled into IR.
///
/// This is the core primitive. Models produce these (directly or via compilation),
/// and the runtime validates and executes them.
///
/// # Construction
///
/// `#[non_exhaustive]`, so from outside `car-ir` this must be built with
/// [`Action::new`] (or [`Action::tool_call`] / [`Action::state_write`] /
/// [`Action::state_read`]) and then mutated — struct-literal syntax, including
/// functional update (`..other`), is rejected in other crates.
///
/// That is the point. `car-ir` is published on crates.io and re-exported by
/// `car-runtime`, so while the *wire* format tolerates new fields (they carry
/// `#[serde(default)]`, and a proposal authored before a field existed still
/// deserializes), the *Rust API* previously did not: every added field was a
/// source-breaking `error[E0063]` for every out-of-tree consumer building an
/// `Action` literal, and cost ~20 files of churn in-tree the last time it
/// happened. Adding a field is now backwards-compatible in both directions.
/// Parslee-ai/car#855.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Action {
    #[serde(default = "short_id")]
    pub id: String,

    #[serde(rename = "type")]
    pub action_type: ActionType,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<String>,

    #[serde(default)]
    pub parameters: HashMap<String, Value>,

    #[serde(default)]
    pub preconditions: Vec<Precondition>,

    #[serde(default)]
    pub expected_effects: HashMap<String, Value>,

    #[serde(default)]
    pub state_dependencies: Vec<String>,

    /// Explicit transactional **read set** — the state keys this action
    /// reads (survey §5.2.4: "each action should declare its read set,
    /// write set, assumptions, version dependencies"). When empty, the
    /// effective read set falls back to [`Action::effective_read_set`]
    /// (derived from `state_dependencies` + assumption keys), so existing
    /// proposals keep working. Used to detect read-write conflicts and
    /// stale reads across concurrent actions/agents.
    #[serde(default)]
    pub read_set: Vec<String>,

    /// Explicit transactional **write set** — the state keys this action
    /// writes. When empty, falls back to [`Action::effective_write_set`]
    /// (derived from `expected_effects` + a `StateWrite`'s `key` param).
    #[serde(default)]
    pub write_set: Vec<String>,

    /// Assumptions this action makes about shared state it did not itself
    /// produce — the basis for belief-divergence / stale-read detection in
    /// a multi-agent transaction (§5.2.4). An assumption can pin an
    /// expected value, a version the action read at, or both.
    #[serde(default)]
    pub assumptions: Vec<StateAssumption>,

    /// How a `ToolCall` runs: `one_shot` (default — dispatch awaits the
    /// result inline), or a detached mode (`streaming` / `long_running`)
    /// where dispatch *starts* the tool, returns a [`crate::ToolHandle`]
    /// as the action's output, and the DAG proceeds without blocking on
    /// completion. Chunks/status are consumed via the handle (C2).
    /// Ignored for non-ToolCall actions.
    #[serde(default)]
    pub invocation_mode: crate::tool_stream::ToolInvocationMode,

    /// The rollback contract for this action's effects — **can this be
    /// undone?** Orthogonal to `car_policy::PermissionTier`, which answers the
    /// separate question of *who may authorize this*; the two were conflated
    /// in a single ladder until this field existed. See [`Reversibility`] for
    /// the axis, and for why the `#[serde(default)]` is the conservative
    /// [`Reversibility::Irreversible`] rather than the quiet-failing
    /// [`Reversibility::Reversible`].
    ///
    /// Nothing in the runtime gates on this yet — it is typed and audited, not
    /// enforced (see the [`reversibility`](crate::reversibility) module docs).
    #[serde(default)]
    pub reversibility: Reversibility,

    /// How to undo this action once it has already run. Meaningful only when
    /// `reversibility` is [`Reversibility::Compensable`]: a reversible action
    /// is undone by restoring its scope, and an irreversible one cannot be
    /// undone at all.
    ///
    /// The pairing is not enforced by the type system — `Compensable` is a
    /// bare variant, not `Compensable { compensation }`, so
    /// `Compensable` + `None` is representable. That is a deliberate trade,
    /// argued in [`Compensation`]'s docs: making the state unrepresentable
    /// costs `Reversibility` its plain C-like shape, which every FFI surface
    /// mirrors as a string enum. [`Action::missing_required_compensation`] is
    /// the check that stands in for the type.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compensation: Option<Compensation>,

    #[serde(default)]
    pub idempotent: bool,

    #[serde(default = "default_max_retries")]
    pub max_retries: u32,

    #[serde(default)]
    pub failure_behavior: FailureBehavior,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<u64>,

    #[serde(default)]
    pub metadata: HashMap<String, Value>,
}

fn default_max_retries() -> u32 {
    3
}

/// An assumption an action makes about shared state it did not produce —
/// the unit of belief-divergence detection in a multi-agent transaction
/// (survey "Code as Agent Harness" §5.2.4). Synchronizing artifacts is not
/// enough; agents must also agree on *assumptions*. An action that planned
/// against `config@v3` should be flagged when `config` has since advanced
/// to `v4`, even if no file diff conflicts.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StateAssumption {
    /// The state key the assumption is about.
    pub key: String,
    /// The value the action expects `key` to hold, if it pinned one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_value: Option<Value>,
    /// The version of `key` the action read when it planned, if known.
    /// Compared against the current version to detect stale reads.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub read_version: Option<u64>,
}

impl Action {
    /// A new action of `action_type`, with every optional field at its
    /// default and a freshly generated [`Action::id`].
    ///
    /// **This is the only way to build an `Action` from outside `car-ir`.**
    /// The struct is `#[non_exhaustive]` (see its docs), so struct-literal
    /// syntax — including functional update, `..other` — is rejected in other
    /// crates. Set the fields you need afterwards; they are all public:
    ///
    /// ```
    /// # use car_ir::{Action, ActionType};
    /// let mut a = Action::new(ActionType::ToolCall);
    /// a.tool = Some("deploy".into());
    /// a.idempotent = true;
    /// ```
    ///
    /// There is deliberately **no** `Default for Action`. An action's type
    /// decides what the rest of it means, and defaulting it would let
    /// `Action::default()` produce a `ToolCall` naming no tool — a value that
    /// is invalid the moment it exists, and that the validator would have to
    /// reject. Requiring the type at construction makes that unrepresentable.
    pub fn new(action_type: ActionType) -> Self {
        Self {
            id: short_id(),
            action_type,
            tool: None,
            parameters: HashMap::new(),
            preconditions: Vec::new(),
            expected_effects: HashMap::new(),
            state_dependencies: Vec::new(),
            read_set: Vec::new(),
            write_set: Vec::new(),
            assumptions: Vec::new(),
            invocation_mode: crate::tool_stream::ToolInvocationMode::default(),
            reversibility: Reversibility::default(),
            compensation: None,
            idempotent: false,
            max_retries: default_max_retries(),
            failure_behavior: FailureBehavior::default(),
            timeout_ms: None,
            metadata: HashMap::new(),
        }
    }

    /// An [`ActionType::ToolCall`] naming `tool`.
    pub fn tool_call(tool: impl Into<String>) -> Self {
        let mut a = Self::new(ActionType::ToolCall);
        a.tool = Some(tool.into());
        a
    }

    /// An [`ActionType::StateWrite`] of `value` to `key`, carrying both the
    /// `key`/`value` parameters the executor reads and the `expected_effects`
    /// entry the static verifier reads.
    pub fn state_write(key: impl Into<String>, value: Value) -> Self {
        let key = key.into();
        let mut a = Self::new(ActionType::StateWrite);
        a.parameters
            .insert("key".to_string(), Value::String(key.clone()));
        a.parameters.insert("value".to_string(), value.clone());
        a.expected_effects.insert(key, value);
        a
    }

    /// An [`ActionType::StateRead`] of `key`.
    pub fn state_read(key: impl Into<String>) -> Self {
        let mut a = Self::new(ActionType::StateRead);
        a.parameters
            .insert("key".to_string(), Value::String(key.into()));
        a
    }

    /// Replace the generated [`Action::id`]. Chainable, so a caller that cares
    /// about the id can still write one expression.
    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.id = id.into();
        self
    }

    /// Set one parameter. Chainable.
    pub fn with_param(mut self, key: impl Into<String>, value: Value) -> Self {
        self.parameters.insert(key.into(), value);
        self
    }

    /// The keys this action writes — the **union** of the explicit
    /// `write_set` with the keys derived from `expected_effects` and a
    /// `StateWrite` action's `key` parameter. Union, not replacement: a
    /// partial `write_set` must never *narrow* the real write footprint, or
    /// a conflict on an unlisted side-effect key would go undetected (a
    /// false negative in the soundness-critical path). Proposals authored
    /// before the transactional fields existed still participate via the
    /// derived keys.
    pub fn effective_write_set(&self) -> Vec<String> {
        let mut keys: Vec<String> = self.write_set.clone();
        let push = |k: String, keys: &mut Vec<String>| {
            if !keys.contains(&k) {
                keys.push(k);
            }
        };
        for k in self.expected_effects.keys() {
            push(k.clone(), &mut keys);
        }
        if self.action_type == ActionType::StateWrite {
            if let Some(k) = self.parameters.get("key").and_then(|v| v.as_str()) {
                push(k.to_string(), &mut keys);
            }
        }
        keys
    }

    /// The keys this action reads — the **union** of the explicit `read_set`
    /// with `state_dependencies`, assumption keys, and a `StateRead`
    /// action's `key` parameter. Union for the same soundness reason as
    /// [`Action::effective_write_set`].
    pub fn effective_read_set(&self) -> Vec<String> {
        let mut keys: Vec<String> = self.read_set.clone();
        let push = |k: String, keys: &mut Vec<String>| {
            if !keys.contains(&k) {
                keys.push(k);
            }
        };
        for k in &self.state_dependencies {
            push(k.clone(), &mut keys);
        }
        for a in &self.assumptions {
            push(a.key.clone(), &mut keys);
        }
        if self.action_type == ActionType::StateRead {
            if let Some(k) = self.parameters.get("key").and_then(|v| v.as_str()) {
                push(k.to_string(), &mut keys);
            }
        }
        keys
    }

    /// Whether this action claims [`Reversibility::Compensable`] but declares
    /// no [`Action::compensation`] — the one incoherent combination the enum
    /// could not exclude by construction (see [`Compensation`] for why the
    /// compensation is a sibling field rather than a variant payload).
    ///
    /// It is a *check*, not a guarantee: it catches the missing declaration,
    /// not a declaration that names a tool which cannot actually reverse the
    /// effect. Nothing here can establish that a compensating call is a true
    /// inverse — that remains the author's claim, exactly as
    /// `expected_effects` is.
    pub fn missing_required_compensation(&self) -> bool {
        self.reversibility.requires_compensation() && self.compensation.is_none()
    }
}

/// A batch of actions proposed by a model for runtime validation and execution.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ActionProposal {
    #[serde(default = "short_id")]
    pub id: String,

    #[serde(default = "default_source")]
    pub source: String,

    pub actions: Vec<Action>,

    #[serde(default = "Utc::now")]
    pub timestamp: DateTime<Utc>,

    #[serde(default)]
    pub context: HashMap<String, Value>,
}

fn default_source() -> String {
    "unknown".to_string()
}

impl ActionProposal {
    /// The rollback contract of the batch as a whole: the **least** reversible
    /// contract any of its actions carries, via the severity ordering on
    /// [`Reversibility`]. A plan is only as recoverable as its least
    /// recoverable step — one irreversible action in an otherwise reversible
    /// batch makes the batch irreversible, because partial execution is a real
    /// outcome (it is exactly the failure mode `StaticVerificationGate` exists
    /// to prevent on multi-action proposals).
    ///
    /// An empty proposal is [`Reversibility::Reversible`], not the
    /// `Irreversible` default: the default answers "the author did not say",
    /// which warrants assuming the worst, whereas an empty batch has no
    /// effects at all and there is nothing to be pessimistic about.
    pub fn rollback_contract(&self) -> Reversibility {
        self.actions
            .iter()
            .map(|a| a.reversibility)
            .max()
            .unwrap_or(Reversibility::Reversible)
    }
}

/// The outcome of executing a single action.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ActionResult {
    pub action_id: String,
    pub status: ActionStatus,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<Value>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,

    #[serde(default)]
    pub state_changes: HashMap<String, Value>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<f64>,

    #[serde(default = "Utc::now")]
    pub timestamp: DateTime<Utc>,
}

/// Rate limit configuration for a tool.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolRateLimit {
    pub max_calls: u32,
    pub interval_secs: f64,
}

/// Rich schema describing a tool's interface and runtime configuration.
///
/// Carries everything the runtime needs: parameter validation via JSON Schema,
/// idempotency hints, caching policy, and rate limiting.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolSchema {
    pub name: String,
    #[serde(default)]
    pub description: String,
    /// JSON Schema for parameters (e.g. `{"type": "object", "properties": {...}, "required": [...]}`)
    #[serde(default = "default_parameters_schema")]
    pub parameters: Value,
    /// JSON Schema for return value (optional)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub returns: Option<Value>,
    /// Whether this tool is idempotent (safe to cache/retry)
    #[serde(default)]
    pub idempotent: bool,
    /// If set, results are cached with this TTL in seconds
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_ttl_secs: Option<u64>,
    /// If set, rate limited to this many calls per interval
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit: Option<ToolRateLimit>,
}

fn default_parameters_schema() -> Value {
    Value::Object(Default::default())
}

/// Cost summary for a proposal execution.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CostSummary {
    pub tool_calls: u32,
    /// Actions that actually ran — `Succeeded` plus `Failed`. A failed action
    /// executed and consumed real work (the tool ran and errored), so it counts;
    /// a *rejected* one never started and is counted in
    /// [`Self::actions_rejected`] instead. Rejections used to land here, which
    /// reported "2 actions executed" for a proposal where nothing ran at all
    /// (Parslee-ai/car#624).
    pub actions_executed: u32,
    /// Actions blocked before execution — by the validator (unknown tool,
    /// unsatisfied dependency) or by policy. Nothing ran, so these cost nothing
    /// beyond the check itself.
    ///
    /// `#[serde(default)]` so a payload written by an older CAR still
    /// deserializes; it simply reports 0.
    #[serde(default)]
    pub actions_rejected: u32,
    pub actions_skipped: u32,
    pub total_duration_ms: f64,
    pub retries: u32,
}

/// Soft optimization targets for proposal cost.
///
/// Unlike `CostBudget` (hard limits that reject proposals), `CostTarget` is used
/// by the planner to score proposals on a cost-vs-success curve. The `cost_weight`
/// controls how aggressively the planner favors cheaper proposals.
///
/// score = success_likelihood * (1 - cost_weight) + cost_efficiency * cost_weight
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CostTarget {
    /// Target number of tool calls (proposals below this get full cost score).
    pub target_tool_calls: u32,
    /// Target total duration in milliseconds.
    pub target_duration_ms: f64,
    /// Target number of actions.
    pub target_actions: u32,
    /// Weight for cost in scoring (0.0–1.0). 0 = ignore cost, 1 = only cost.
    pub cost_weight: f64,
}

impl Default for CostTarget {
    fn default() -> Self {
        Self {
            target_tool_calls: 5,
            target_duration_ms: 5000.0,
            target_actions: 10,
            cost_weight: 0.2,
        }
    }
}

/// The complete result of processing a proposal through the runtime.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProposalResult {
    pub proposal_id: String,

    #[serde(default)]
    pub results: Vec<ActionResult>,

    #[serde(default)]
    pub cost: CostSummary,
}

impl ProposalResult {
    pub fn all_succeeded(&self) -> bool {
        self.results
            .iter()
            .all(|r| r.status == ActionStatus::Succeeded)
    }

    pub fn summary(&self) -> HashMap<ActionStatus, usize> {
        let mut counts = HashMap::new();
        for r in &self.results {
            *counts.entry(r.status.clone()).or_insert(0) += 1;
        }
        counts
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn constructors_fill_defaults_and_leave_the_wire_unchanged() {
        // The migration's contract (Parslee-ai/car#855): `Action::new` must
        // produce exactly what a full struct literal produced, so converting
        // ~100 call sites off literals changed no behaviour. If a future field
        // is added to the struct but not to `new`, this stops compiling —
        // which is the point.
        let a = Action::new(ActionType::ToolCall);
        assert_eq!(a.action_type, ActionType::ToolCall);
        assert!(a.tool.is_none());
        assert!(a.parameters.is_empty());
        assert!(a.preconditions.is_empty());
        assert!(a.expected_effects.is_empty());
        assert!(a.state_dependencies.is_empty());
        assert!(a.read_set.is_empty());
        assert!(a.write_set.is_empty());
        assert!(a.assumptions.is_empty());
        assert_eq!(a.reversibility, Reversibility::default());
        assert!(a.compensation.is_none());
        assert!(!a.idempotent);
        assert_eq!(a.max_retries, default_max_retries());
        assert_eq!(a.failure_behavior, FailureBehavior::Abort);
        assert!(a.timeout_ms.is_none());
        assert!(a.metadata.is_empty());
        assert_eq!(a.id.len(), 12, "id is a generated short id");

        // The typed shortcuts agree with the long form.
        assert_eq!(Action::tool_call("deploy").tool.as_deref(), Some("deploy"));

        let sw = Action::state_write("k", Value::from(1));
        assert_eq!(sw.action_type, ActionType::StateWrite);
        assert_eq!(sw.parameters["key"], Value::from("k"));
        assert_eq!(sw.parameters["value"], Value::from(1));
        // The verifier reads the effect, the executor reads the parameters —
        // a `state_write` that set only one of them would silently defeat
        // write-conflict detection.
        assert_eq!(sw.expected_effects["k"], Value::from(1));
        assert_eq!(sw.effective_write_set(), vec!["k".to_string()]);

        let sr = Action::state_read("k");
        assert_eq!(sr.action_type, ActionType::StateRead);
        assert_eq!(sr.parameters["key"], Value::from("k"));

        // Chainable setters.
        let c = Action::tool_call("t")
            .with_id("fixed")
            .with_param("p", Value::from(2));
        assert_eq!(c.id, "fixed");
        assert_eq!(c.parameters["p"], Value::from(2));
    }

    #[test]
    fn action_type_serializes_snake_case() {
        assert_eq!(
            serde_json::to_string(&ActionType::ToolCall).unwrap(),
            "\"tool_call\""
        );
        assert_eq!(
            serde_json::to_string(&ActionType::StateWrite).unwrap(),
            "\"state_write\""
        );
    }

    #[test]
    fn failure_behavior_serializes_snake_case() {
        assert_eq!(
            serde_json::to_string(&FailureBehavior::Abort).unwrap(),
            "\"abort\""
        );
        assert_eq!(
            serde_json::to_string(&FailureBehavior::Retry).unwrap(),
            "\"retry\""
        );
    }

    #[test]
    fn action_roundtrip_json() {
        let action = Action {
            id: "abc123".to_string(),
            action_type: ActionType::ToolCall,
            tool: Some("add".to_string()),
            parameters: [
                ("a".to_string(), Value::from(1)),
                ("b".to_string(), Value::from(2)),
            ]
            .into(),
            preconditions: vec![Precondition {
                key: "auth".to_string(),
                operator: "eq".to_string(),
                value: Value::Bool(true),
                description: String::new(),
            }],
            expected_effects: [("sum".to_string(), Value::from(3))].into(),
            state_dependencies: vec!["auth".to_string()],
            read_set: vec![],
            write_set: vec![],
            assumptions: vec![],
            invocation_mode: Default::default(),
            reversibility: Reversibility::Compensable,
            compensation: Some(Compensation::Tool {
                tool: "subtract".to_string(),
                parameters: [("sum".to_string(), Value::from(3))].into(),
            }),
            idempotent: true,
            max_retries: 3,
            failure_behavior: FailureBehavior::Retry,
            timeout_ms: Some(5000),
            metadata: HashMap::new(),
        };

        let json = serde_json::to_string_pretty(&action).unwrap();
        let roundtripped: Action = serde_json::from_str(&json).unwrap();

        assert_eq!(action.id, roundtripped.id);
        assert_eq!(action.action_type, roundtripped.action_type);
        assert_eq!(action.tool, roundtripped.tool);
        assert_eq!(action.idempotent, roundtripped.idempotent);
        assert_eq!(action.failure_behavior, roundtripped.failure_behavior);
        assert_eq!(action.timeout_ms, roundtripped.timeout_ms);
        assert_eq!(action.reversibility, roundtripped.reversibility);
        assert_eq!(action.compensation, roundtripped.compensation);
        assert_eq!(action, roundtripped);
    }

    #[test]
    fn proposal_roundtrip_json() {
        let proposal = ActionProposal {
            id: "prop1".to_string(),
            source: "test".to_string(),
            actions: vec![Action {
                id: "a1".to_string(),
                action_type: ActionType::StateWrite,
                tool: None,
                parameters: [
                    ("key".to_string(), Value::from("x")),
                    ("value".to_string(), Value::from(42)),
                ]
                .into(),
                preconditions: vec![],
                expected_effects: HashMap::new(),
                state_dependencies: vec![],
                read_set: vec![],
                write_set: vec![],
                assumptions: vec![],
                invocation_mode: Default::default(),
                reversibility: Reversibility::Reversible,
                compensation: None,
                idempotent: false,
                max_retries: 3,
                failure_behavior: FailureBehavior::Abort,
                timeout_ms: None,
                metadata: HashMap::new(),
            }],
            timestamp: Utc::now(),
            context: HashMap::new(),
        };

        let json = serde_json::to_string(&proposal).unwrap();
        let roundtripped: ActionProposal = serde_json::from_str(&json).unwrap();

        assert_eq!(proposal.id, roundtripped.id);
        assert_eq!(proposal.source, roundtripped.source);
        assert_eq!(proposal.actions.len(), roundtripped.actions.len());
    }

    #[test]
    fn action_result_serializes() {
        let result = ActionResult {
            action_id: "a1".to_string(),
            status: ActionStatus::Succeeded,
            output: Some(Value::from(42)),
            error: None,
            state_changes: HashMap::new(),
            duration_ms: Some(1.5),
            timestamp: Utc::now(),
        };

        let json = serde_json::to_string(&result).unwrap();
        assert!(json.contains("\"succeeded\""));
    }

    #[test]
    fn proposal_result_all_succeeded() {
        let pr = ProposalResult {
            proposal_id: "p1".to_string(),
            results: vec![
                ActionResult {
                    action_id: "a1".to_string(),
                    status: ActionStatus::Succeeded,
                    output: None,
                    error: None,
                    state_changes: HashMap::new(),
                    duration_ms: None,
                    timestamp: Utc::now(),
                },
                ActionResult {
                    action_id: "a2".to_string(),
                    status: ActionStatus::Succeeded,
                    output: None,
                    error: None,
                    state_changes: HashMap::new(),
                    duration_ms: None,
                    timestamp: Utc::now(),
                },
            ],
            cost: CostSummary::default(),
        };
        assert!(pr.all_succeeded());
    }

    #[test]
    fn proposal_result_not_all_succeeded() {
        let pr = ProposalResult {
            proposal_id: "p1".to_string(),
            results: vec![
                ActionResult {
                    action_id: "a1".to_string(),
                    status: ActionStatus::Succeeded,
                    output: None,
                    error: None,
                    state_changes: HashMap::new(),
                    duration_ms: None,
                    timestamp: Utc::now(),
                },
                ActionResult {
                    action_id: "a2".to_string(),
                    status: ActionStatus::Failed,
                    output: None,
                    error: Some("boom".to_string()),
                    state_changes: HashMap::new(),
                    duration_ms: None,
                    timestamp: Utc::now(),
                },
            ],
            cost: CostSummary::default(),
        };
        assert!(!pr.all_succeeded());
    }

    #[test]
    fn cost_summary_default_is_zero() {
        let cost = CostSummary::default();
        assert_eq!(cost.tool_calls, 0);
        assert_eq!(cost.actions_executed, 0);
        assert_eq!(cost.actions_rejected, 0);
        assert_eq!(cost.actions_skipped, 0);
        assert_eq!(cost.total_duration_ms, 0.0);
        assert_eq!(cost.retries, 0);
    }

    /// A summary written before `actions_rejected` existed must still load.
    #[test]
    fn cost_summary_deserializes_without_actions_rejected() {
        let legacy = r#"{"tool_calls":1,"actions_executed":2,"actions_skipped":0,
                         "total_duration_ms":5.0,"retries":0}"#;
        let cost: CostSummary = serde_json::from_str(legacy).unwrap();
        assert_eq!(cost.actions_executed, 2);
        assert_eq!(cost.actions_rejected, 0);
    }

    #[test]
    fn cost_summary_serde_roundtrip() {
        let cost = CostSummary {
            tool_calls: 3,
            actions_executed: 5,
            actions_rejected: 2,
            actions_skipped: 1,
            total_duration_ms: 42.5,
            retries: 2,
        };
        let json = serde_json::to_string(&cost).unwrap();
        let roundtripped: CostSummary = serde_json::from_str(&json).unwrap();
        assert_eq!(cost, roundtripped);
    }

    #[test]
    fn proposal_result_deserializes_without_cost() {
        // Backward compatibility: old JSON without cost field should still deserialize
        let json = r#"{"proposal_id": "p1", "results": []}"#;
        let pr: ProposalResult = serde_json::from_str(json).unwrap();
        assert_eq!(pr.cost, CostSummary::default());
    }

    #[test]
    fn deserialize_from_python_compatible_json() {
        // This JSON must match what Python's model_dump_json() produces
        let json = r#"{
            "id": "test123",
            "type": "tool_call",
            "tool": "add",
            "parameters": {"a": 1, "b": 2},
            "preconditions": [],
            "expected_effects": {"sum": 3},
            "state_dependencies": [],
            "idempotent": true,
            "max_retries": 3,
            "failure_behavior": "retry",
            "timeout_ms": 5000,
            "metadata": {}
        }"#;

        let action: Action = serde_json::from_str(json).unwrap();
        assert_eq!(action.id, "test123");
        assert_eq!(action.action_type, ActionType::ToolCall);
        assert_eq!(action.tool, Some("add".to_string()));
        assert!(action.idempotent);
        assert_eq!(action.failure_behavior, FailureBehavior::Retry);
        assert_eq!(action.timeout_ms, Some(5000));
    }

    /// The backward-compatibility contract the rest of the runtime depends on:
    /// a proposal authored before `reversibility` / `compensation` existed —
    /// including one that predates the transactional and streaming fields —
    /// must still deserialize, landing on the conservative default rather than
    /// failing.
    #[test]
    fn action_deserializes_without_reversibility_fields() {
        let legacy = r#"{
            "id": "legacy1",
            "type": "tool_call",
            "tool": "send_email",
            "parameters": {"to": "a@b.c"},
            "preconditions": [],
            "expected_effects": {},
            "state_dependencies": [],
            "idempotent": false,
            "max_retries": 3,
            "failure_behavior": "abort",
            "metadata": {}
        }"#;

        let action: Action = serde_json::from_str(legacy).unwrap();
        assert_eq!(action.id, "legacy1");
        assert_eq!(action.reversibility, Reversibility::Irreversible);
        assert_eq!(action.compensation, None);
        // The default is not the incoherent state — `Irreversible` needs no
        // compensation, so an un-annotated legacy action never trips the check.
        assert!(!action.missing_required_compensation());
    }

    /// The same contract one level up: a whole proposal written by an older
    /// CAR (or an older binding) still loads, and every action in it defaults.
    #[test]
    fn proposal_deserializes_without_reversibility_fields() {
        let legacy = r#"{
            "id": "prop-legacy",
            "source": "python",
            "actions": [
                {"id": "a1", "type": "state_write", "parameters": {"key": "x", "value": 1}},
                {"id": "a2", "type": "tool_call", "tool": "add", "parameters": {}}
            ],
            "context": {}
        }"#;

        let proposal: ActionProposal = serde_json::from_str(legacy).unwrap();
        assert_eq!(proposal.actions.len(), 2);
        for action in &proposal.actions {
            assert_eq!(action.reversibility, Reversibility::Irreversible);
            assert!(action.compensation.is_none());
        }
        assert_eq!(proposal.rollback_contract(), Reversibility::Irreversible);
    }

    /// `compensation` is `skip_serializing_if = "Option::is_none"`, so an
    /// action that declares no compensation emits no key at all — an older
    /// consumer sees exactly the payload shape it saw before.
    #[test]
    fn absent_compensation_is_omitted_from_the_wire_form() {
        let mut action: Action =
            serde_json::from_str(r#"{"id":"a1","type":"tool_call","tool":"noop"}"#).unwrap();
        action.reversibility = Reversibility::Reversible;

        let json = serde_json::to_value(&action).unwrap();
        assert_eq!(json["reversibility"], "reversible");
        assert!(
            json.get("compensation").is_none(),
            "compensation should be skipped when None, got {json}"
        );
    }

    #[test]
    fn compensable_without_compensation_is_flagged() {
        let mut action: Action =
            serde_json::from_str(r#"{"id":"a1","type":"tool_call","tool":"db.insert"}"#).unwrap();

        action.reversibility = Reversibility::Compensable;
        assert!(action.missing_required_compensation());

        action.compensation = Some(Compensation::ActionRef {
            action_id: "undo-a1".to_string(),
        });
        assert!(!action.missing_required_compensation());

        // A compensation declared alongside a non-compensable contract is
        // pointless but not incoherent — the check stays quiet about it.
        action.reversibility = Reversibility::Reversible;
        assert!(!action.missing_required_compensation());
    }

    #[test]
    fn rollback_contract_is_the_worst_action_in_the_batch() {
        let mut proposal: ActionProposal = serde_json::from_str(
            r#"{"id":"p1","source":"test","actions":[
                {"id":"a1","type":"state_write","parameters":{"key":"x"},"reversibility":"reversible"},
                {"id":"a2","type":"tool_call","tool":"db.insert","reversibility":"compensable",
                 "compensation":{"type":"tool","tool":"db.delete","parameters":{"id":1}}}
            ]}"#,
        )
        .unwrap();
        assert_eq!(proposal.rollback_contract(), Reversibility::Compensable);

        proposal.actions[0].reversibility = Reversibility::Irreversible;
        assert_eq!(proposal.rollback_contract(), Reversibility::Irreversible);

        // Nothing to undo is not the same as "unclassified", so an empty
        // batch does not inherit the pessimistic default.
        proposal.actions.clear();
        assert_eq!(proposal.rollback_contract(), Reversibility::Reversible);
    }
}