Struct RequestContext 

#[non_exhaustive]
pub struct RequestContext {
    pub message: Message,
    pub task_id: TaskId,
    pub context_id: String,
    pub stored_task: Option<Task>,
    pub metadata: Option<Value>,
    pub cancellation_token: CancellationToken,
    pub call_context: Option<CallContext>,
}

Context for a single agent execution request.

Built by the RequestHandler and passed to AgentExecutor::execute.

The cancellation_token allows executors to observe cancellation requests and abort work cooperatively.

call_context carries who the caller is, which tenant they resolved to, the HTTP headers they sent and the extensions they activated. Before 0.13 an executor could see none of that — it was built into a CallContext the handler never passed on — so an executor could not enforce “only this tenant may invoke this skill”, and the only channel for anything caller-specific was Message.metadata.

#[non_exhaustive] since 0.13: this type grows, and every previous growth was a breaking change for a struct literal nobody was writing. Build one with new and the with_* methods.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

message: Message

The incoming user message.

task_id: TaskId

The task identifier for this execution.

context_id: String

The conversation context identifier.

stored_task: Option<Task>

The previously stored task snapshot, if this is a continuation.

metadata: Option<Value>

Arbitrary metadata from the request.

cancellation_token: CancellationToken

Cancellation token for cooperative task cancellation.

Executors should check CancellationToken::is_cancelled or .cancelled().await to stop work when the task is cancelled.

call_context: Option<CallContext>

The call this execution belongs to: caller identity, tenant, HTTP headers, activated extensions, method name and request id.

None when the executor is driven directly rather than served — a unit test, a conformance harness — which is the honest answer there rather than a synthetic context claiming a call that never happened. Prefer the accessors (caller_identity, tenant, http_header, activated_extensions) over matching on this directly.

Implementations

impl RequestContext

pub fn new( message: Message, task_id: TaskId, context_id: String, ) -> RequestContext

Creates a new RequestContext.

pub fn with_stored_task(self, task: Task) -> RequestContext

Sets the stored task snapshot for continuation requests.

pub fn with_metadata(self, metadata: Value) -> RequestContext

Sets request metadata.

pub fn with_call_context(self, call_context: CallContext) -> RequestContext

Attaches the CallContext this execution was requested under.

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

Who the caller is, if authentication established an identity.

None means either that no interceptor authenticated the call or that this context was built without one. An executor that must refuse anonymous work should treat None as a refusal rather than a default.

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

The tenant this call resolved to, after any TenantResolver has had its say.

This is the value to use inside an executor. TenantContext::current is a task-local that tokio::spawn does not inherit, so it reads empty in some executor contexts; this field is an owned copy taken before the spawn.

pub fn http_header(&self, name: &str) -> Option<&str>

One inbound HTTP header, matched case-insensitively.

pub fn activated_extensions(&self) -> &[String]

The extension URIs the caller activated for this request, from the A2A-Extensions header (spec §14.2.2).

pub fn trace_context(&self) -> Option<&TraceContext>

The W3C trace this execution belongs to, when the caller sent a traceparent.

Propagate it verbatim on any outbound A2A call and the delegation chain becomes one trace rather than several unrelated span trees:

if let Some(tc) = ctx.trace_context() {
    CurrentTrace::scope(tc.clone(), async {
        client.send_message(params).await
    })
    .await?;
}

None means the caller was not tracing. It never means the SDK invented one.

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

The caller’s request/trace id, from X-Request-ID if they sent one.

Trait Implementations

impl Clone for RequestContext

fn clone(&self) -> RequestContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestContext

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

Formats the value using the given formatter.