Extensions
Tasks can optionally take in extensions. Extensions are simply singletons dependency injected into your task to provide some capability. Here's an example using the SandboxProvider extension, which allows your agent to create sandboxes, which it can start, execute commands on, and later stop.
#[derive(Deserialize, Serialize)]
struct SandboxConfig {}
async fn sandbox_task(
context: TaskContext,
TaskConfig(config): TaskConfig<SandboxConfig>,
Extension(provider): Extension<dyn SandboxProvider>,
) -> Result<TaskResult, TaskError> {
let mut sandbox = provider
.create(SandboxSpec::new(config.image_id.clone()))
.await?;
let command = config
.command
.replace("{trial}", &context.trial_index.to_string());
let output = sandbox.execute(CommandSpec::new(command)).await?;
sandbox.stop().await?;
let cleanup = sandbox.delete().await?;
Ok(TaskResult {
output: json!({
"trial": context.trial_index,
"exit_code": output.exit_code,
"stdout": output.stdout,
"stderr": output.stderr,
}),
})
}Read more in the sandbox docs on how to use this extension.
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut tasks = TaskRegistry::new();
let extensions = TaskExtensions::new();
tasks.register("sandbox", sandbox_task)?;
let sandbox_factory = &tasks.factory("sandbox")?;
// create Archil SandboxProvider
let api_key = std::env::var("ARCHIL_API_KEY")?;
let region = std::env::var("ARCHIL_REGION").unwrap_or_else(|_| "aws-us-east-1".into());
let client = Client::builder(api_key, region).build()?;
let sandbox_provider: Arc<dyn SandboxProvider> = Arc::new(client.sandbox_provider());
// insert sandbox provider extension for the task to receive
extensions.insert(sandbox_provider)?;
let planner = Planner::new(tasks, extensions);
let plan = ResolvedExecutionPlan::new(vec![
ResolvedJobSpec::new(
"sandbox",
sandbox_factory.clone(),
SandboxConfig {},
)?
.trials(5),
]);
let trials = planner.plan(&plan)?;
let scheduler = Scheduler::default();
let results: Vec<Result<TrialRecord, EngineError>> =
scheduler.run(trials).await.collect().await;
println!("{:?}", results);
Ok(())
}When you construct TaskExtensions, you can insert values of any type into it, including a dyn SandboxProvider. This must match the type declared at the task handler. If an extension is not provided, the engine will return an error and your run will fail.
Using dyn traits like this enables swapping out extensions for different implementations at runtime without having to change the actual task implementation. So for example, you can use Docker sandboxes during local development and Archil sandboxes in production.