Struct AgentPlan 

pub struct AgentPlan {
    pub plan_id: PlanId,
    pub agent_id: AgentId,
    pub goal_id: GoalId,
    pub description: String,
    pub status: PlanStatus,
    pub steps: Vec<PlanStep>,
    pub estimated_cost: Option<PlanCost>,
    pub actual_cost: Option<PlanCost>,
    pub created_at: Timestamp,
    pub started_at: Option<Timestamp>,
    pub completed_at: Option<Timestamp>,
}

A plan to achieve a goal.

Fields

plan_id: PlanId

Unique identifier for this plan

agent_id: AgentId

Agent that created this plan

goal_id: GoalId

Goal this plan is for

description: String

Description of the plan

status: PlanStatus

Current status

steps: Vec<PlanStep>

Steps in the plan

estimated_cost: Option<PlanCost>

Estimated cost

actual_cost: Option<PlanCost>

Actual cost (after execution)

created_at: Timestamp

When this plan was created

started_at: Option<Timestamp>

When execution started

completed_at: Option<Timestamp>

When completed

Implementations

impl AgentPlan

pub fn new( agent_id: AgentId, goal_id: GoalId, description: impl Into<String>, ) -> Self

Create a new plan.

pub fn add_step(&mut self, step: PlanStep)

Add a step to the plan.

pub fn with_estimated_cost(self, cost: PlanCost) -> Self

Set estimated cost.

pub fn ready(&mut self)

Mark as ready for execution.

pub fn start(&mut self)

Start execution.

pub fn complete(&mut self, actual_cost: Option<PlanCost>)

Mark as completed.

pub fn next_step(&self) -> Option<&PlanStep>

Get next pending step.

Trait Implementations

impl Clone for AgentPlan

fn clone(&self) -> AgentPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for AgentPlan

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for AgentPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AgentPlan

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AgentPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for AgentPlan

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

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.

impl StructuralPartialEq for AgentPlan