Struct PerCallTools 

pub struct PerCallTools<'w, 's> { /* private fields */ }

The tools registered per call, and where a call of an agent’s works: for a plugin that builds a call somewhere else, as rig-basics’ Preview builds it on an overlay of the workspace, or wraps a call where it works, as its Checkpoint does. The plugin inits ProjectRoot, which this reads: without it the system using this fails. A tool replaced (its entity Disabled) is not seen.

use std::sync::Arc;

use bevy_ecs::system::RunSystemOnce;
use rig_harness::prelude::*;
use rig_harness::rig_core::effect::EffectKind;
use rig_harness::rig_core::message::{ToolFunction, ToolName};
use rig_harness::rig_core::serve::serve_inline;
use rig_harness::rig_tools::{Write, overlay::Overlay};

let mut app = App::new();
app.add_tool_per_call(Write::default(), ToolOptions::default(), |place| Write {
    workspace: place.workspace,
    base: Some(place.base),
    confine: place.confine,
    ..Write::default()
});
// It exists; nothing is written to it.
let dir = std::env::current_dir()?;
let agent = app.world_mut().spawn(WorkDir(dir.clone())).id();
let project = app.world().resource::<ProjectWorkspace>().0.clone();
let overlay = Arc::new(Overlay::new(project));
let on = overlay.clone();
let ran = app.world_mut().run_system_once(move |tools: PerCallTools| {
    let place = tools.place(Some(agent), on.clone());
    let (base, confine) = (place.base.clone(), place.confine);
    let quiet = place.live.is_none() && place.spill.is_none();
    let missing = tools.build("read", tools.place(None, on.clone()));
    (tools.build("write", place), missing, base, confine, quiet)
});
let (write, missing, base, confine, quiet) = ran.map_err(|failure| failure.to_string())?;
assert_eq!(base, dir);
assert!(confine && quiet && missing.is_none());
let CallHandler(handler) = write.ok_or("write is registered per call")?;
let args = serde_json::json!({ "path": "per-call-doc.txt", "content": "one\n" });
let call = ToolCall::from_wire("w1", ToolFunction::new(ToolName::new("write")?, args));
bevy_tasks::block_on(serve_inline(&handler.0, EffectKind::from(&call)))?;
// The write went to the overlay, and not to the disk.
assert_eq!(overlay.changes().len(), 1);
assert!(!dir.join("per-call-doc.txt").exists());

Implementations

impl PerCallTools<'_, '_>

pub fn place( &self, agent: Option<Entity>, workspace: Arc<dyn Workspace>, ) -> CallPlace

A call of agent‘s working in workspace: its base is the agent’s WorkDir, which confines it, else the ProjectRoot. It has no live and no spill, so a call built on an overlay writes nowhere else; a call that runs for real elsewhere sets spill itself (Scratch::spill). confine limits the file tools’ paths; it is no process sandbox.

pub fn build(&self, name: &str, place: CallPlace) -> Option<CallHandler>

The handler of a call of the per-call tool name built for place; None when no enabled tool of that name is registered per call. It runs nothing.

Trait Implementations

impl<'w, 's> ReadOnlySystemParam for PerCallTools<'w, 's>

where Query<'w, 's, (&'static ToolDef, &'static PerCall)>: ReadOnlySystemParam, Query<'w, 's, &'static WorkDir>: ReadOnlySystemParam, Res<'w, ProjectRoot>: ReadOnlySystemParam,

impl SystemParam for PerCallTools<'_, '_>

type State = FetchState

Used to store data which persists across invocations of a system.

type Item<'w, 's> = PerCallTools<'w, 's>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World) -> Self::State

Creates a new instance of this param’s State.

fn init_access( state: &Self::State, system_meta: &mut SystemMeta, system_access: &mut SystemAccess, world: &mut World, )

Registers any World access used by this SystemParam.

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Result<Self::Item<'w, 's>, SystemParamValidationError>

Creates a parameter to be passed into a SystemParamFunction.