Struct TaskContext 

pub struct TaskContext {
    pub forge: Option<Forge>,
    pub workflow_id: String,
    pub task_id: TaskId,
    pub task_timeout: Option<Duration>,
    pub tool_registry: Option<Arc<ToolRegistry>>,
    pub audit_log: Option<AuditLog>,
    /* private fields */
}

Execution context provided to workflow tasks.

Provides access to the Forge SDK for graph operations, metadata about the current workflow execution, and cancellation token.

Fields

forge: Option<Forge>

Optional Forge instance for graph queries

workflow_id: String

Workflow identifier for this execution

task_id: TaskId

Task identifier for this execution

task_timeout: Option<Duration>

Optional task timeout duration

tool_registry: Option<Arc<ToolRegistry>>

Optional tool registry for tool invocation

audit_log: Option<AuditLog>

Optional audit log for recording events (cloned from executor)

Implementations

impl TaskContext

pub fn new(workflow_id: impl Into<String>, task_id: TaskId) -> Self

Creates a new TaskContext.

pub fn with_forge(self, forge: Forge) -> Self

Sets the Forge instance for graph operations.

pub fn with_cancellation_token(self, token: CancellationToken) -> Self

Sets the cancellation token for cooperative cancellation.

Arguments

• token - The cancellation token to check during task execution

Returns

The context with cancellation token set (for builder pattern)

Example

use forge_agent::workflow::{CancellationTokenSource, TaskContext};

let source = CancellationTokenSource::new();
let context = TaskContext::new("workflow-1", task_id)
    .with_cancellation_token(source.token());

pub fn cancellation_token(&self) -> Option<&CancellationToken>

Returns a reference to the cancellation token if set.

Tasks can use this to check for cancellation during execution.

Example

async fn execute(&self, context: &TaskContext) -> Result<TaskResult, TaskError> {
    if let Some(token) = context.cancellation_token() {
        if token.is_cancelled() {
            return Ok(TaskResult::Skipped);
        }
    }
    // ... do work
}

pub fn with_task_timeout(self, timeout: Duration) -> Self

Sets the task timeout for this context.

Arguments

• timeout - The timeout duration for the task

Returns

The context with task timeout set (for builder pattern)

Example

use std::time::Duration;

let context = TaskContext::new("workflow-1", task_id)
    .with_task_timeout(Duration::from_secs(30));

pub fn with_tool_registry(self, registry: Arc<ToolRegistry>) -> Self

Sets the tool registry for tool invocation.

Arguments

• registry - The tool registry to use for tool invocation

Returns

The context with tool registry set (for builder pattern)

Example

use forge_agent::workflow::tools::ToolRegistry;
use std::sync::Arc;

let registry = Arc::new(ToolRegistry::new());
let context = TaskContext::new("workflow-1", task_id)
    .with_tool_registry(registry);

pub fn tool_registry(&self) -> Option<&Arc<ToolRegistry>>

Returns a reference to the tool registry if set.

Returns

• Some(&Arc<ToolRegistry>) if tool registry is set
• None if no tool registry

Example

if let Some(registry) = context.tool_registry() {
    // Use tool registry
}

pub fn with_audit_log(self, audit_log: AuditLog) -> Self

Sets the audit log for event recording.

Arguments

• audit_log - The audit log to use for event recording

Returns

The context with audit log set (for builder pattern)

Example

use forge_agent::audit::AuditLog;

let audit_log = AuditLog::new();
let context = TaskContext::new("workflow-1", task_id)
    .with_audit_log(audit_log);

pub fn audit_log_mut(&mut self) -> Option<&mut AuditLog>

Returns a mutable reference to the audit log if set.

Returns

• Some(&mut AuditLog) if audit log is set
• None if no audit log

Example

if let Some(audit_log) = context.audit_log_mut() {
    // Use audit log
}

pub fn task_timeout(&self) -> Option<Duration>

Returns the task timeout duration if set.

Example

if let Some(timeout) = context.task_timeout() {
    println!("Task timeout: {:?}", timeout);
}

Trait Implementations

impl Clone for TaskContext

fn clone(&self) -> TaskContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.