Struct DependencyMap 

pub struct DependencyMap { /* private fields */ }

Implementations

impl DependencyMap

pub fn new() -> Self

pub fn insert<T>(&self, value: T)

where T: Send + Sync + 'static,

pub fn get<T>(&self) -> Option<Arc<T>>

where T: Send + Sync + 'static,

Examples found in repository

examples/di_override.rs (line 52)

async fn main() -> Result<(), Box<dyn Error>> {
    let read_dep_tool = ToolSpec::new("read_dep", "read injected value")
        .with_schema(json!({
            "type": "object",
            "properties": {},
            "required": [],
            "additionalProperties": false
        }))?
        .with_handler(|_args, deps| {
            let value = deps.get::<u32>().map(|v| *v).unwrap_or_default();
            async move { Ok(ToolOutcome::Text(value.to_string())) }
        });

    let done_tool = ToolSpec::new("done", "finish")
        .with_schema(json!({
            "type": "object",
            "properties": {
                "message": {"type": "string"}
            },
            "required": ["message"],
            "additionalProperties": false
        }))?
        .with_handler(|args, _deps| async move {
            let message = args
                .get("message")
                .and_then(|v| v.as_str())
                .unwrap_or("done");
            Ok(ToolOutcome::Done(message.to_string()))
        });

    let model = ScriptedModel::new(vec![
        Ok(ModelCompletion {
            text: None,
            thinking: None,
            tool_calls: vec![ModelToolCall {
                id: "call_1".to_string(),
                name: "read_dep".to_string(),
                arguments: json!({}),
            }],
            usage: None,
        }),
        Ok(ModelCompletion {
            text: None,
            thinking: None,
            tool_calls: vec![ModelToolCall {
                id: "call_2".to_string(),
                name: "done".to_string(),
                arguments: json!({"message": "dependency override applied"}),
            }],
            usage: None,
        }),
    ]);

    let mut agent = Agent::builder()
        .model(model)
        .tool(read_dep_tool)
        .tool(done_tool)
        .dependency(1_u32)
        .dependency_override(9_u32)
        .build()?;

    let response = agent.query("use dependency").await?;
    println!("final: {response}");

    Ok(())
}

pub fn insert_named<T>(&self, key: impl Into<String>, value: T)

where T: Send + Sync + 'static,

pub fn get_named<T>(&self, key: &str) -> Option<Arc<T>>

where T: Send + Sync + 'static,

pub fn merged_with(&self, overrides: &DependencyMap) -> DependencyMap

Trait Implementations

impl Clone for DependencyMap

fn clone(&self) -> DependencyMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DependencyMap

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

Formats the value using the given formatter.

impl Default for DependencyMap

fn default() -> DependencyMap

Returns the “default value” for a type.