Struct AgentPromptPacket 

pub struct AgentPromptPacket<T> {
    pub workflow_name: Name,
    pub goal: Purpose,
    pub event: Event,
    pub input: T,
    pub policies: Vec<PolicyInstruction>,
    pub output_schema_name: OutputSchemaName,
}

Safe prompt-and-evidence packet exchanged with an automation agent.

Operator framing: this is the checklist packet an agent receives for one reviewable workflow run. It matters to managers because every suggested action, brief, classification, or customer-message draft should trace back to the workflow name, source event, approved input facts, policy instructions, and expected output shape recorded here.

Next step: compare the packet fields with the workflow’s AgentSpec and review gates before treating any generated output as usable evidence. The field-level Rustdoc below documents the API shape; it does not grant live authority to book, charge, message, schedule, or override policy.

An agent prompt packet bundles the workflow identity, triggering source event, typed app input, policy instructions, and expected output schema sent to an agent runner. It is a draft/evidence gate: agents can use it to prepare a briefing, follow-up draft, classification, or manager-review packet, but the packet itself is not permission to mutate live resort systems.

Fields

workflow_name: Name

Workflow identifier that ties the packet to a specific agent spec.

Examples include manager-daily-brief, booking-triage, and grooming-rebooking; the name lets audits connect a packet back to the workflow rules that defined its allowed tools and forbidden actions.

goal: Purpose

Business goal the agent should pursue while preparing only draft output.

This describes the labor, customer-service, safety, or data-quality outcome for the workflow, such as summarizing labor risk or drafting a customer follow-up, without granting authority to perform the action.

event: Event

Source workflow event that caused the packet to be built.

The event provides audit correlation for the triggering reservation, intake, document, review, incident, or scheduled briefing path so a human reviewer can trace why this packet exists.

input: T

Typed app-layer input facts available to the agent for this run.

The payload should contain the workflow-specific request or evidence the app has already promoted from source systems; it is context for drafting, not authorization to repair or overwrite those source records.

policies: Vec<PolicyInstruction>

Policy instructions the runner must include in the agent context.

These instructions state review gates, safety limits, escalation rules, and source-grounding requirements that constrain agent drafts and make policy compliance reviewable after the run.

output_schema_name: OutputSchemaName

Name of the output schema expected from the agent.

The schema name tells the runner and validator which structured draft, classification, briefing, or evidence bundle shape to expect before any downstream workflow code accepts the output.

Implementations

impl<T> AgentPromptPacket<T>

pub fn builder() -> AgentPromptPacketBuilder<T>

Create an instance of AgentPromptPacket using the builder syntax

Trait Implementations

impl<T: Clone> Clone for AgentPromptPacket<T>

fn clone(&self) -> AgentPromptPacket<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AgentPromptPacket<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for AgentPromptPacket<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for AgentPromptPacket<T>

fn eq(&self, other: &AgentPromptPacket<T>) -> 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<T> Serialize for AgentPromptPacket<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for AgentPromptPacket<T>

impl<T> StructuralPartialEq for AgentPromptPacket<T>