Struct AgentContext 

pub struct AgentContext {

    pub task_description: String,
    pub round_number: u32,
    pub total_rounds: u32,
    pub phase: DeliberationPhase,
    pub target_proposal: Option<Proposal>,
    pub competitor_summaries: Vec<String>,
    pub previous_round_matrix: Option<String>,
    pub previous_own_proposal: Option<Proposal>,
    pub previous_own_score: Option<f32>,
    pub previous_critiques: Vec<String>,
    pub scratchpad: Option<String>,
    pub store: Option<Arc<dyn PersistenceStore>>,
    pub candidates: Vec<CandidateProposal>,
    pub user_injections: Vec<UserInjection>,
    pub user_tools: Vec<UserToolDefinition>,
    pub phase_budget_remaining_secs: f64,
    pub session_id: Option<String>,
    pub conversation_id: Option<String>,
    pub new_turn: Option<String>,
    pub structured_feedback: Option<StructuredFeedback>,
    pub forced_proposal_schema: Option<Value>,
    pub working_dir_override: Option<PathBuf>,
    pub user_tool_handler: Option<Arc<dyn UserToolHandlerTrait>>,
    pub role: Option<String>,
    pub role_context: Option<String>,
    pub agent_id: String,
    pub task_publish_ts: Option<i64>,
    pub telemetry: Option<TelemetryEmitterMux>,
    pub submission_validator: Option<Arc<dyn SubmissionValidator>>,
    pub event_store: Option<AgentEventStore>,
}

Fields

task_description: String

round_number: u32

total_rounds: u32

phase: DeliberationPhase

target_proposal: Option<Proposal>

competitor_summaries: Vec<String>

previous_round_matrix: Option<String>

previous_own_proposal: Option<Proposal>

previous_own_score: Option<f32>

previous_critiques: Vec<String>

scratchpad: Option<String>

store: Option<Arc<dyn PersistenceStore>>

candidates: Vec<CandidateProposal>

user_injections: Vec<UserInjection>

user_tools: Vec<UserToolDefinition>

User-defined tool definitions for this job. Empty if none registered.

phase_budget_remaining_secs: f64

Remaining phase budget in seconds at the time the task was published. The agent uses this as the upper bound for user tool call wait times.

session_id: Option<String>

The session/job ID for NATS subject construction within the agent worker.

conversation_id: Option<String>

Stable conversation key for the claude-CLI session, when a job belongs to a longer-lived thread whose session_id/room_id is minted fresh per turn (the OpenAI-compat path). The deterministic claude session UUID is keyed on this so successive turns of one thread --resume the same transcript. None falls back to session_id (the thread-TUI path, where the room is the stable thread id).

new_turn: Option<String>

The new turn only (this job’s incremental user message), when the thread’s prior turns already live in the resumed claude session. Used as the delta prompt’s task on a resumed session so we don’t re-send the whole flattened task_description (which the session already holds). None → the delta falls back to task_description (fresh session / non-thread paths).

structured_feedback: Option<StructuredFeedback>

Structured feedback from previous round’s evaluations (Phase 2 context pipeline).

forced_proposal_schema: Option<Value>

A JSON schema a before_prompt middleware declared for the proposal submission. When set, the propose tool’s parameters are constrained to it and the terminal tool call is forced (tool_choice: required) — the model must return a schema-valid structured proposal. Runtime-only.

working_dir_override: Option<PathBuf>

A per-task working directory a before_prompt middleware declared (via the agent_working_dir key on its content). When set, the agent subprocess runs with cwd = this dir instead of the process launch dir, so relative reads/writes land where the middleware prepared them. Overrides the agent’s static working_dir. Runtime-only.

user_tool_handler: Option<Arc<dyn UserToolHandlerTrait>>

Runtime-only: handler for user tool calls (injected by agent worker, not serialized). The concrete type is supplied via UserToolHandlerFactory; this field holds an opaque Arc wrapper.

role: Option<String>

Role assigned to this agent by the broker (from policy-based scheduling). None for static agent list mode or legacy payloads.

role_context: Option<String>

Per-role private context content (not visible to other agents). Populated from the role’s context files by the orchestrator.

agent_id: String

Identity of the agent processing this task. Populated by the dispatcher (orchestrator at construction time, worker after deserialize) so the agent and any downstream helpers (e.g. AgentContext::telemetry_for) don’t need to thread the same id through every call site. #[serde(default)] on the field tolerates payloads serialized before the field existed; populated paths keep the value end-to-end.

task_publish_ts: Option<i64>

Unix ms the orchestrator stamped at publish time; None on pre-stamping payloads, synthetic contexts, and resurrected envelopes. Paired with task_received to compute TaskAccepted.job_age_at_accept_ms.

telemetry: Option<TelemetryEmitterMux>

Runtime-only: per-task telemetry mux populated by the agent worker. Agents pass context.telemetry.as_ref() into generate_structured_output / react_loop so LLM, tool, retry, and prompt-exposure events fan out across every configured endpoint under the same (agent_id, job_id, round, phase) envelope as the worker’s task-lifecycle events. Mirrors the store / user_tool_handler runtime-only pattern: skipped by serde, excluded from generated schemas.

submission_validator: Option<Arc<dyn SubmissionValidator>>

Runtime-only: validates a submit_proposal submission inside the react loop. Injected by the agent worker from the provider_response middleware so a reviewer block (e.g. patch-deliberation “applied ZERO changes”) feeds the reason back through the SAME retry that handles parse failures — no separate retry budget. Mirrors the user_tool_handler runtime-only pattern.

event_store: Option<AgentEventStore>

Runtime-only: the agent’s own NATS event log. Injected by the worker so the react loop can record tool-call start/finish for the operator dashboard’s 24h history. Mirrors the telemetry runtime-only pattern: skipped by serde, excluded from generated schemas.

Implementations

impl AgentContext

pub fn claude_session_key(&self) -> Option<&str>

The key the deterministic claude-CLI session UUID is derived from: conversation_id (a thread stable across turns) when set, else session_id (the per-job/room id). This is what makes successive turns of one thread resume the same transcript.

pub fn delta_task(&self) -> &str

The task text a resumed session’s delta prompt should carry: the new turn only when set (the prior turns already live in the session), else the full task_description (fresh session / non-thread paths). This is what stops a resumed thread from re-sending its whole flattened history.

pub fn telemetry_for(&self) -> TelemetryContext

Build a TelemetryContext for telemetry events emitted while processing this task.

Uses the context’s own agent_id, session_id, round_number, and phase. Pair with [emit_for!] at the call site:

emit_for!(context, ToolCallExecuted {
    tool_name: name, latency_ms: 42, success: true,
});

Panics

session_id is a dispatch-time invariant: the orchestrator populates it on every published task. Emitting telemetry from a context with no session is a programmer error, typically a test that constructed an AgentContext literal without setting session_id. Panics with a helpful message rather than synthesising a fake job_id that would silently break trace correlation across the catalog.

Trait Implementations

impl Clone for AgentContext

fn clone(&self) -> AgentContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for AgentContext

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

impl Debug for AgentContext

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

Formats the value using the given formatter.

impl Default for AgentContext

fn default() -> AgentContext

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AgentContext

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for AgentContext

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

The name of the generated JSON Schema.

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

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for AgentContext

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 AgentContext

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

Return name of the schema.

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

Implement reference utoipa::openapi::schema::Schemas for this type.