Struct ControlClient 

pub struct ControlClient { /* private fields */ }

Implementations

impl ControlClient

pub async fn set_variable<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/control_state_structured_variables.rs (lines 29-34)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_state_structured_variables";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_state_structured_variables");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control structured variable state-management".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let variable_name = "planner_state";
        let value_json = json!({ "phase": "draft", "confidence": 0.91_f32 }).to_string();

        let set = client
            .control
            .set_variable(json!({
                "run_id": run_id,
                "name": variable_name,
                "value_json": value_json,
                "source": "explicit",
            }))
            .await?;
        require(
            set.get("success").and_then(Value::as_bool).unwrap_or(false),
            format!("set_variable failed: {set}"),
        )?;

        let get = client
            .control
            .get_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;
        let list = client
            .control
            .list_variables(json!({ "run_id": run_id }))
            .await?;
        let delete = client
            .control
            .delete_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;

        require(get.is_object(), format!("get_variable failed: {get}"))?;
        require(list.is_object(), format!("list_variables failed: {list}"))?;
        require(
            delete
                .get("success")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("delete_variable failed: {delete}"),
        )?;

        let variables = list
            .get("variables")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("list_variables payload invalid: {list}")))?;
        require(
            variables
                .iter()
                .any(|entry| entry.get("name").and_then(Value::as_str) == Some(variable_name)),
            format!("variable not present in list_variables: {list}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "variable_name": variable_name,
            "variable_count": variables.len(),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/legacy_state_compatibility.rs (line 25)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 25)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn get_variable<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/control_state_structured_variables.rs (line 43)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_state_structured_variables";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_state_structured_variables");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control structured variable state-management".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let variable_name = "planner_state";
        let value_json = json!({ "phase": "draft", "confidence": 0.91_f32 }).to_string();

        let set = client
            .control
            .set_variable(json!({
                "run_id": run_id,
                "name": variable_name,
                "value_json": value_json,
                "source": "explicit",
            }))
            .await?;
        require(
            set.get("success").and_then(Value::as_bool).unwrap_or(false),
            format!("set_variable failed: {set}"),
        )?;

        let get = client
            .control
            .get_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;
        let list = client
            .control
            .list_variables(json!({ "run_id": run_id }))
            .await?;
        let delete = client
            .control
            .delete_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;

        require(get.is_object(), format!("get_variable failed: {get}"))?;
        require(list.is_object(), format!("list_variables failed: {list}"))?;
        require(
            delete
                .get("success")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("delete_variable failed: {delete}"),
        )?;

        let variables = list
            .get("variables")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("list_variables payload invalid: {list}")))?;
        require(
            variables
                .iter()
                .any(|entry| entry.get("name").and_then(Value::as_str) == Some(variable_name)),
            format!("variable not present in list_variables: {list}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "variable_name": variable_name,
            "variable_count": variables.len(),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/legacy_state_compatibility.rs (line 26)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 26)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn list_variables<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/control_state_structured_variables.rs (line 47)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_state_structured_variables";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_state_structured_variables");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control structured variable state-management".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let variable_name = "planner_state";
        let value_json = json!({ "phase": "draft", "confidence": 0.91_f32 }).to_string();

        let set = client
            .control
            .set_variable(json!({
                "run_id": run_id,
                "name": variable_name,
                "value_json": value_json,
                "source": "explicit",
            }))
            .await?;
        require(
            set.get("success").and_then(Value::as_bool).unwrap_or(false),
            format!("set_variable failed: {set}"),
        )?;

        let get = client
            .control
            .get_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;
        let list = client
            .control
            .list_variables(json!({ "run_id": run_id }))
            .await?;
        let delete = client
            .control
            .delete_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;

        require(get.is_object(), format!("get_variable failed: {get}"))?;
        require(list.is_object(), format!("list_variables failed: {list}"))?;
        require(
            delete
                .get("success")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("delete_variable failed: {delete}"),
        )?;

        let variables = list
            .get("variables")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("list_variables payload invalid: {list}")))?;
        require(
            variables
                .iter()
                .any(|entry| entry.get("name").and_then(Value::as_str) == Some(variable_name)),
            format!("variable not present in list_variables: {list}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "variable_name": variable_name,
            "variable_count": variables.len(),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/legacy_state_compatibility.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn delete_variable<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/control_state_structured_variables.rs (line 51)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_state_structured_variables";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_state_structured_variables");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control structured variable state-management".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let variable_name = "planner_state";
        let value_json = json!({ "phase": "draft", "confidence": 0.91_f32 }).to_string();

        let set = client
            .control
            .set_variable(json!({
                "run_id": run_id,
                "name": variable_name,
                "value_json": value_json,
                "source": "explicit",
            }))
            .await?;
        require(
            set.get("success").and_then(Value::as_bool).unwrap_or(false),
            format!("set_variable failed: {set}"),
        )?;

        let get = client
            .control
            .get_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;
        let list = client
            .control
            .list_variables(json!({ "run_id": run_id }))
            .await?;
        let delete = client
            .control
            .delete_variable(json!({ "run_id": run_id, "name": variable_name }))
            .await?;

        require(get.is_object(), format!("get_variable failed: {get}"))?;
        require(list.is_object(), format!("list_variables failed: {list}"))?;
        require(
            delete
                .get("success")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("delete_variable failed: {delete}"),
        )?;

        let variables = list
            .get("variables")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("list_variables payload invalid: {list}")))?;
        require(
            variables
                .iter()
                .any(|entry| entry.get("name").and_then(Value::as_str) == Some(variable_name)),
            format!("variable not present in list_variables: {list}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "variable_name": variable_name,
            "variable_count": variables.len(),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/legacy_state_compatibility.rs (line 28)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 28)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn define_concept<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 30)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 30)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn list_concepts<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 31)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 31)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn add_goal<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/goal_tree_and_goal_update.rs (line 23)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_goal_tree_and_goal_update";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_goal_tree");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw goal tree lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let parent = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let parent_id = parent.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal parent failed: {parent}")))?.to_string();
        let child = client.control.add_goal(json!({"run_id": run_id, "description": "Verify receipts", "priority": "medium", "parent_goal_id": parent_id})).await?;
        let child_id = child.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal child failed: {child}")))?.to_string();
        let updated = client.control.update_goal(json!({"run_id": run_id, "goal_id": child_id, "status": "achieved"})).await?;
        let listed = client.control.list_goals(json!({"run_id": run_id})).await?;
        let tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": parent_id})).await?;
        require(updated.get("success").and_then(Value::as_bool).unwrap_or(true), format!("update_goal failed: {updated}"))?;
        require(listed.get("goals").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(child_id.as_str()))).unwrap_or(false), format!("list_goals missing child: {listed}"))?;
        require(tree.get("goals").is_some() || tree.get("root").is_some() || tree.get("nodes").is_some(), format!("goal tree malformed: {tree}"))?;
        metrics = json!({"run_id": run_id, "parent_goal_id": parent_id, "child_goal_id": child_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/internal/legacy_state_compatibility.rs (line 33)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 33)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn update_goal<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/goal_tree_and_goal_update.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_goal_tree_and_goal_update";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_goal_tree");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw goal tree lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let parent = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let parent_id = parent.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal parent failed: {parent}")))?.to_string();
        let child = client.control.add_goal(json!({"run_id": run_id, "description": "Verify receipts", "priority": "medium", "parent_goal_id": parent_id})).await?;
        let child_id = child.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal child failed: {child}")))?.to_string();
        let updated = client.control.update_goal(json!({"run_id": run_id, "goal_id": child_id, "status": "achieved"})).await?;
        let listed = client.control.list_goals(json!({"run_id": run_id})).await?;
        let tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": parent_id})).await?;
        require(updated.get("success").and_then(Value::as_bool).unwrap_or(true), format!("update_goal failed: {updated}"))?;
        require(listed.get("goals").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(child_id.as_str()))).unwrap_or(false), format!("list_goals missing child: {listed}"))?;
        require(tree.get("goals").is_some() || tree.get("root").is_some() || tree.get("nodes").is_some(), format!("goal tree malformed: {tree}"))?;
        metrics = json!({"run_id": run_id, "parent_goal_id": parent_id, "child_goal_id": child_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/internal/legacy_state_compatibility.rs (line 35)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 41)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn list_goals<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/goal_tree_and_goal_update.rs (line 28)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_goal_tree_and_goal_update";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_goal_tree");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw goal tree lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let parent = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let parent_id = parent.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal parent failed: {parent}")))?.to_string();
        let child = client.control.add_goal(json!({"run_id": run_id, "description": "Verify receipts", "priority": "medium", "parent_goal_id": parent_id})).await?;
        let child_id = child.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal child failed: {child}")))?.to_string();
        let updated = client.control.update_goal(json!({"run_id": run_id, "goal_id": child_id, "status": "achieved"})).await?;
        let listed = client.control.list_goals(json!({"run_id": run_id})).await?;
        let tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": parent_id})).await?;
        require(updated.get("success").and_then(Value::as_bool).unwrap_or(true), format!("update_goal failed: {updated}"))?;
        require(listed.get("goals").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(child_id.as_str()))).unwrap_or(false), format!("list_goals missing child: {listed}"))?;
        require(tree.get("goals").is_some() || tree.get("root").is_some() || tree.get("nodes").is_some(), format!("goal tree malformed: {tree}"))?;
        metrics = json!({"run_id": run_id, "parent_goal_id": parent_id, "child_goal_id": child_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/internal/legacy_state_compatibility.rs (line 36)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 42)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn get_goal_tree<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/goal_tree_and_goal_update.rs (line 29)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_goal_tree_and_goal_update";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_goal_tree");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw goal tree lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let parent = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let parent_id = parent.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal parent failed: {parent}")))?.to_string();
        let child = client.control.add_goal(json!({"run_id": run_id, "description": "Verify receipts", "priority": "medium", "parent_goal_id": parent_id})).await?;
        let child_id = child.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal child failed: {child}")))?.to_string();
        let updated = client.control.update_goal(json!({"run_id": run_id, "goal_id": child_id, "status": "achieved"})).await?;
        let listed = client.control.list_goals(json!({"run_id": run_id})).await?;
        let tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": parent_id})).await?;
        require(updated.get("success").and_then(Value::as_bool).unwrap_or(true), format!("update_goal failed: {updated}"))?;
        require(listed.get("goals").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(child_id.as_str()))).unwrap_or(false), format!("list_goals missing child: {listed}"))?;
        require(tree.get("goals").is_some() || tree.get("root").is_some() || tree.get("nodes").is_some(), format!("goal tree malformed: {tree}"))?;
        metrics = json!({"run_id": run_id, "parent_goal_id": parent_id, "child_goal_id": child_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/internal/legacy_state_compatibility.rs (line 37)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 43)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn submit_action<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 39)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 45)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn get_action_log<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 40)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 46)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn run_cycle<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 41)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 47)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn get_cycle_history<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 42)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 48)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn register_agent<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn agent_heartbeat<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn append_activity<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn context_snapshot<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn link_run<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 43)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 49)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn unlink_run<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/legacy_state_compatibility.rs (line 44)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_legacy_state_compatibility";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_legacy_state_compatibility");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_legacy_state_compat.rs (line 50)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_legacy_state_compat";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_legacy_state_compat");
    let linked_run_id = new_run_id("control_legacy_state_linked");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated legacy state compatibility APIs".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let set_var = client.control.set_variable(json!({"run_id": run_id, "name": "claim_status", "value_json": json!({"value": "triage"}).to_string(), "source": "explicit"})).await?;
        let get_var = client.control.get_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;
        let list_vars = client.control.list_variables(json!({"run_id": run_id})).await?;
        let delete_var = client.control.delete_variable(json!({"run_id": run_id, "name": "claim_status"})).await?;

        let define_concept = client.control.define_concept(json!({"run_id": run_id, "name": "claim", "schema_json": json!({"type": "object", "properties": {"status": {"type": "string"}}}).to_string()})).await?;
        let list_concepts = client.control.list_concepts(json!({"run_id": run_id})).await?;

        let add_goal = client.control.add_goal(json!({"run_id": run_id, "description": "Resolve claim", "priority": "high"})).await?;
        let goal_id = add_goal.get("id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("add_goal failed: {add_goal}")))?.to_string();
        let child_goal = client.control.add_goal(json!({
            "run_id": run_id,
            "description": "Verify receipts",
            "priority": "medium",
            "parent_goal_id": goal_id,
        })).await?;
        let update_goal = client.control.update_goal(json!({"run_id": run_id, "goal_id": goal_id, "status": "suspended"})).await?;
        let list_goals = client.control.list_goals(json!({"run_id": run_id})).await?;
        let goal_tree = client.control.get_goal_tree(json!({"run_id": run_id, "root_goal_id": goal_id})).await?;

        let submit_action = client.control.submit_action(json!({"run_id": run_id, "agent_id": "planner", "action_type": "note", "action_json": json!({"step": "inspect facts"}).to_string()})).await?;
        let action_log = client.control.get_action_log(json!({"run_id": run_id, "limit": 10})).await?;
        let run_cycle = client.control.run_cycle(json!({"run_id": run_id, "agent_id": "planner", "candidates": [{"action_type": "inspect", "action_json": json!({"target": "claim facts"}).to_string(), "score": 0.9, "rationale": "highest confidence"}]})).await?;
        let cycle_history = client.control.get_cycle_history(json!({"run_id": run_id, "limit": 10})).await?;
        let link_run = client.control.link_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;
        let unlink_run = client.control.unlink_run(json!({"run_id": run_id, "linked_run_id": linked_run_id})).await?;

        require(set_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("set_variable failed: {set_var}"))?;
        require(get_var.get("name").and_then(Value::as_str) == Some("claim_status"), format!("get_variable failed: {get_var}"))?;
        require(list_vars.get("variables").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim_status"))).unwrap_or(false), format!("list_variables failed: {list_vars}"))?;
        require(delete_var.get("success").and_then(Value::as_bool).unwrap_or(false), format!("delete_variable failed: {delete_var}"))?;
        require(define_concept.get("success").and_then(Value::as_bool).unwrap_or(false), format!("define_concept failed: {define_concept}"))?;
        require(list_concepts.get("concepts").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("name").and_then(Value::as_str) == Some("claim"))).unwrap_or(false), format!("list_concepts failed: {list_concepts}"))?;
        require(child_goal.get("id").and_then(Value::as_str).is_some(), format!("child add_goal failed: {child_goal}"))?;
        require(update_goal.get("success").and_then(Value::as_bool).unwrap_or(false), format!("update_goal failed: {update_goal}"))?;
        require(list_goals.get("goals").and_then(Value::as_array).map(|items| items.iter().any(|item| item.get("id").and_then(Value::as_str) == Some(goal_id.as_str()))).unwrap_or(false), format!("list_goals failed: {list_goals}"))?;
        require(
            goal_tree.get("root").is_some()
                || goal_tree.get("nodes").is_some()
                || goal_tree.get("goals").and_then(Value::as_array).is_some(),
            format!("goal_tree failed: {goal_tree}"),
        )?;
        require(submit_action.get("success").and_then(Value::as_bool).unwrap_or(false), format!("submit_action failed: {submit_action}"))?;
        require(action_log.get("entries").and_then(Value::as_array).is_some(), format!("action_log failed: {action_log}"))?;
        let cycle_number_valid = run_cycle.get("cycle_number").and_then(Value::as_u64).is_some()
            || run_cycle
                .get("cycle_number")
                .and_then(Value::as_str)
                .map(|value| value.chars().all(|ch| ch.is_ascii_digit()))
                .unwrap_or(false);
        require(cycle_number_valid, format!("run_cycle failed: {run_cycle}"))?;
        require(cycle_history.get("cycles").and_then(Value::as_array).is_some(), format!("cycle_history failed: {cycle_history}"))?;
        require(link_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("link_run failed: {link_run}"))?;
        require(unlink_run.get("success").and_then(Value::as_bool).unwrap_or(false), format!("unlink_run failed: {unlink_run}"))?;

        metrics = json!({
            "run_id": run_id,
            "goal_id": goal_id,
            "action_id": submit_action.get("action_id").cloned().unwrap_or(Value::Null),
            "cycle_number": run_cycle.get("cycle_number").cloned().unwrap_or(Value::Null),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn ingest<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/control_ingest_batch_job_lifecycle.rs (lines 24-36)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_control_ingest_batch_job_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_control_ingest_batch");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw control ingest and batch lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client.control.ingest(json!({
            "run_id": run_id,
            "agent_id": "rust-sdk-example",
            "parallel": false,
            "items": [{
                "item_id": "incident-1",
                "content_type": "text",
                "text": "Incident SEV2-7314: cache warmer rollback restored baseline latency.",
                "payload_json": "",
                "hints_json": "{\"priority\":\"high\"}",
                "metadata_json": "{\"source\":\"ops-incident\"}"
            }]
        })).await?;
        let job_id = accepted.get("job_id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?.to_string();

        let mut job: Option<Value> = None;
        for _ in 0..60 {
            let current = client.control.get_ingest_job(json!({"run_id": run_id, "job_id": job_id})).await?;
            if current.get("done").and_then(Value::as_bool).unwrap_or(false) { job = Some(current); break; }
            sleep(Duration::from_millis(250)).await;
        }
        let job = job.ok_or_else(|| boxed_error("timeout waiting for ingest job completion"))?;

        let batch = client.control.batch_insert(json!({
            "run_id": run_id,
            "deduplicate": true,
            "items": [
                {"item_id": "batch-1", "text": "Release checkpoint reduced p95 latency.", "metadata_json": "{\"source\":\"release\"}", "source": "rust-sdk-batch", "embedding": []},
                {"item_id": "batch-2", "text": "Warehouse QA hold can be released after clean cycles.", "metadata_json": "{\"source\":\"warehouse\"}", "source": "rust-sdk-batch", "embedding": []}
            ]
        })).await?;

        require(job.get("status").and_then(Value::as_str) == Some("completed"), format!("job should be completed: {job}"))?;
        require(batch.get("count").and_then(Value::as_u64).unwrap_or(0) >= 2, format!("expected batch inserts: {batch}"))?;

        metrics = json!({"run_id": run_id, "job_id": job_id, "batch_count": batch.get("count").cloned().unwrap_or(Value::Null)});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_ingest_idempotency.rs (lines 28-51)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_ingest_idempotency";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_ingest_idempotency");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control ingest idempotency".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let idempotency_key = format!("idempotency-{run_id}");

        let first = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": idempotency_key,
                "parallel": false,
                "items": [
                    {
                        "item_id": "release-risk-1",
                        "content_type": "text",
                        "text": "Release planning memo: mobile v5.12 RC is blocked by an Android 15 beta crash loop triggered during background sync with low-memory pressure.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"release-risk\"}",
                        "metadata_json": "{\"source\":\"release-management\",\"platform\":\"android\",\"track\":\"v5.12\"}",
                    },
                    {
                        "item_id": "finance-recon-2",
                        "content_type": "text",
                        "text": "Finance operations note: invoice batch B-4402 contained three duplicate vendor IDs; reconciliation script flagged records for manual approval.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"billing\"}",
                        "metadata_json": "{\"source\":\"finance-ops\",\"batch\":\"B-4402\",\"workflow\":\"reconciliation\"}",
                    }
                ],
            }))
            .await?;

        let second = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": idempotency_key,
                "parallel": false,
                "items": [{
                    "item_id": "procurement-followup-3",
                    "content_type": "text",
                    "text": "Procurement update: alternate supplier onboarding for lithium cells was escalated after lead-time slipped from 11 to 19 days in Q1 forecasts.",
                    "payload_json": "",
                    "hints_json": "{\"priority\":\"medium\",\"signal\":\"supply-chain\"}",
                    "metadata_json": "{\"source\":\"procurement\",\"component\":\"lithium-cell\",\"quarter\":\"Q1\"}",
                }],
            }))
            .await?;

        let first_job_id = first
            .get("job_id")
            .or_else(|| first.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("first ingest missing job_id: {first}")))?;
        let second_job_id = second
            .get("job_id")
            .or_else(|| second.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("second ingest missing job_id: {second}")))?;

        require(
            first_job_id == second_job_id,
            format!("idempotency should reuse job_id: {first} vs {second}"),
        )?;
        require(
            second
                .get("deduplicated")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("second ingest should be deduplicated: {second}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "job_id": first_job_id,
            "second_deduplicated": second.get("deduplicated").cloned().unwrap_or(Value::Bool(false)),
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/upsert_key_idempotency.rs (lines 28-51)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_upsert_key_idempotency";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_upsert_key_idempotency");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated raw upsert key idempotency".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let idempotency_key = format!("idempotency-{run_id}");

        let first = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": idempotency_key,
                "parallel": false,
                "items": [
                    {
                        "item_id": "release-risk-1",
                        "content_type": "text",
                        "text": "Release planning memo: mobile v5.12 RC is blocked by an Android 15 beta crash loop triggered during background sync with low-memory pressure.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"release-risk\"}",
                        "metadata_json": "{\"source\":\"release-management\",\"platform\":\"android\",\"track\":\"v5.12\"}",
                    },
                    {
                        "item_id": "finance-recon-2",
                        "content_type": "text",
                        "text": "Finance operations note: invoice batch B-4402 contained three duplicate vendor IDs; reconciliation script flagged records for manual approval.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"billing\"}",
                        "metadata_json": "{\"source\":\"finance-ops\",\"batch\":\"B-4402\",\"workflow\":\"reconciliation\"}",
                    }
                ],
            }))
            .await?;

        let second = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": idempotency_key,
                "parallel": false,
                "items": [{
                    "item_id": "procurement-followup-3",
                    "content_type": "text",
                    "text": "Procurement update: alternate supplier onboarding for lithium cells was escalated after lead-time slipped from 11 to 19 days in Q1 forecasts.",
                    "payload_json": "",
                    "hints_json": "{\"priority\":\"medium\",\"signal\":\"supply-chain\"}",
                    "metadata_json": "{\"source\":\"procurement\",\"component\":\"lithium-cell\",\"quarter\":\"Q1\"}",
                }],
            }))
            .await?;

        let first_job_id = first
            .get("job_id")
            .or_else(|| first.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("first ingest missing job_id: {first}")))?;
        let second_job_id = second
            .get("job_id")
            .or_else(|| second.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("second ingest missing job_id: {second}")))?;

        require(
            first_job_id == second_job_id,
            format!("idempotency should reuse job_id: {first} vs {second}"),
        )?;
        require(
            second
                .get("deduplicated")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("second ingest should be deduplicated: {second}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "job_id": first_job_id,
            "second_deduplicated": second.get("deduplicated").cloned().unwrap_or(Value::Bool(false)),
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/control_ingest_job_lifecycle.rs (lines 27-58)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_ingest_job_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_ingest_job_lifecycle");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control ingest job lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": format!("ingest-job-{}", run_id),
                "parallel": false,
                "items": [
                    {
                        "item_id": "incident-latency-1",
                        "content_type": "text",
                        "text": "Incident SEV2-7314 at 2026-02-14T03:22:00Z: checkout API latency in us-east rose from 180ms to 2.4s after cache warmer v1.8.1 rollout; rollback restored baseline.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"performance\"}",
                        "metadata_json": "{\"source\":\"ops-incident\",\"region\":\"us-east\",\"service\":\"checkout-api\"}",
                    },
                    {
                        "item_id": "customer-advisory-2",
                        "content_type": "text",
                        "text": "Customer advisory draft: EU enterprise tenant requested SLA clarification for batch exports; legal referenced DPA section 4.2 and retention requirement of 30 days.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"policy\"}",
                        "metadata_json": "{\"source\":\"customer-success\",\"region\":\"eu-central\",\"team\":\"legal-ops\"}",
                    },
                    {
                        "item_id": "cold-chain-telemetry-3",
                        "content_type": "text",
                        "text": "Warehouse telemetry snapshot: cold-chain lane C7 drifted from 2.1C to 6.4C for 14 minutes; sensor recalibrated and shipment placed on QA hold.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"logistics\"}",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                    }
                ],
            }))
            .await?;

        require(
            accepted
                .get("accepted")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("ingest not accepted: {accepted}"),
        )?;

        let job_id = accepted
            .get("job_id")
            .or_else(|| accepted.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?
            .to_string();

        let mut job: Option<Value> = None;
        for _ in 0..60 {
            let current = client
                .control
                .get_ingest_job(json!({ "run_id": run_id, "job_id": job_id }))
                .await?;
            if current
                .get("done")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                job = Some(current);
                break;
            }
            sleep(Duration::from_millis(250)).await;
        }

        let job = job.ok_or_else(|| boxed_error("timeout waiting for ingest job completion"))?;

        require(
            job.get("done").and_then(Value::as_bool).unwrap_or(false),
            format!("job should be done: {job}"),
        )?;
        require(
            job.get("status").and_then(Value::as_str) == Some("completed"),
            format!("job should be completed: {job}"),
        )?;

        let traces = job
            .get("traces")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("job traces missing: {job}")))?;
        require(!traces.is_empty(), format!("job traces missing: {job}"))?;

        let mut write_count = 0usize;
        let mut successful_writes = 0usize;
        for trace in traces {
            let writes = trace
                .get("writes")
                .and_then(Value::as_array)
                .cloned()
                .unwrap_or_default();
            write_count += writes.len();
            successful_writes += writes
                .iter()
                .filter(|write| {
                    write
                        .get("success")
                        .and_then(Value::as_bool)
                        .unwrap_or(false)
                })
                .count();
        }

        require(
            write_count > 0,
            format!("expected non-empty ingestion writes: {job}"),
        )?;
        require(
            successful_writes > 0,
            format!("expected at least one successful write: {job}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "job_id": job_id,
            "trace_count": traces.len(),
            "write_count": write_count,
            "successful_writes": successful_writes,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/control_query_agent_routed.rs (lines 27-58)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_query_agent_routed";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_query_agent_routed");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control query agent-routed flow".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": format!("query-routed-{}", run_id),
                "parallel": false,
                "items": [
                    {
                        "item_id": "safety-incident-1",
                        "content_type": "text",
                        "text": "Safety briefing: forklift zone B had two near-miss events this week; camera review confirmed blind-spot congestion during shift handoff.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"safety\"}",
                        "metadata_json": "{\"source\":\"warehouse-safety\",\"zone\":\"B\",\"period\":\"weekly\"}",
                    },
                    {
                        "item_id": "product-telemetry-2",
                        "content_type": "text",
                        "text": "Product telemetry: onboarding completion rose from 61% to 74% after removing optional steps, but payment-link retries increased by 9%.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"product-metrics\"}",
                        "metadata_json": "{\"source\":\"product-analytics\",\"funnel\":\"onboarding\",\"metric_window\":\"7d\"}",
                    },
                    {
                        "item_id": "support-escalation-3",
                        "content_type": "text",
                        "text": "Support escalation summary: three enterprise tickets cited delayed audit log exports; root cause traced to a throttling rule on shared workers.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"customer-impact\"}",
                        "metadata_json": "{\"source\":\"support-ops\",\"segment\":\"enterprise\",\"topic\":\"audit-logs\"}",
                    }
                ],
            }))
            .await?;

        let job_id = accepted
            .get("job_id")
            .or_else(|| accepted.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?
            .to_string();

        let mut done = false;
        for _ in 0..60 {
            let current = client
                .control
                .get_ingest_job(json!({ "run_id": run_id, "job_id": job_id }))
                .await?;
            if current
                .get("done")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                done = true;
                break;
            }
            sleep(Duration::from_millis(250)).await;
        }
        require(done, "ingest job did not complete before query")?;

        let response = client
            .control
            .query(json!({
                "run_id": run_id,
                "query": "summarize the safety, product, and support signals captured for this run",
                "schema": "",
                "mode": "agent_routed",
                "direct_lane": "semantic_search",
                "include_linked_runs": false,
                "limit": 5,
                "embedding": [],
            }))
            .await?;

        require(
            response.get("mode").and_then(Value::as_str) == Some("agent_routed"),
            format!("unexpected query mode: {response}"),
        )?;
        require(
            response
                .get("routing_summary")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("routing_summary should be non-empty: {response}"),
        )?;

        let consulted_runs = response
            .get("consulted_runs")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("consulted_runs must be array: {response}")))?;
        require(
            consulted_runs
                .iter()
                .filter_map(Value::as_str)
                .any(|value| value == run_id || value.ends_with(&format!("::{run_id}"))),
            format!("consulted_runs missing primary run_id: {response}"),
        )?;

        require(
            response
                .get("final_answer")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("final_answer should be non-empty: {response}"),
        )?;

        let evidence_count = response
            .get("evidence")
            .and_then(Value::as_array)
            .map(std::vec::Vec::len)
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "job_id": job_id,
            "mode": response.get("mode").cloned().unwrap_or(Value::Null),
            "consulted_runs": consulted_runs,
            "evidence_count": evidence_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

pub async fn batch_insert<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/control_ingest_batch_job_lifecycle.rs (lines 47-54)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_control_ingest_batch_job_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_control_ingest_batch");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw control ingest and batch lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client.control.ingest(json!({
            "run_id": run_id,
            "agent_id": "rust-sdk-example",
            "parallel": false,
            "items": [{
                "item_id": "incident-1",
                "content_type": "text",
                "text": "Incident SEV2-7314: cache warmer rollback restored baseline latency.",
                "payload_json": "",
                "hints_json": "{\"priority\":\"high\"}",
                "metadata_json": "{\"source\":\"ops-incident\"}"
            }]
        })).await?;
        let job_id = accepted.get("job_id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?.to_string();

        let mut job: Option<Value> = None;
        for _ in 0..60 {
            let current = client.control.get_ingest_job(json!({"run_id": run_id, "job_id": job_id})).await?;
            if current.get("done").and_then(Value::as_bool).unwrap_or(false) { job = Some(current); break; }
            sleep(Duration::from_millis(250)).await;
        }
        let job = job.ok_or_else(|| boxed_error("timeout waiting for ingest job completion"))?;

        let batch = client.control.batch_insert(json!({
            "run_id": run_id,
            "deduplicate": true,
            "items": [
                {"item_id": "batch-1", "text": "Release checkpoint reduced p95 latency.", "metadata_json": "{\"source\":\"release\"}", "source": "rust-sdk-batch", "embedding": []},
                {"item_id": "batch-2", "text": "Warehouse QA hold can be released after clean cycles.", "metadata_json": "{\"source\":\"warehouse\"}", "source": "rust-sdk-batch", "embedding": []}
            ]
        })).await?;

        require(job.get("status").and_then(Value::as_str) == Some("completed"), format!("job should be completed: {job}"))?;
        require(batch.get("count").and_then(Value::as_u64).unwrap_or(0) >= 2, format!("expected batch inserts: {batch}"))?;

        metrics = json!({"run_id": run_id, "job_id": job_id, "batch_count": batch.get("count").cloned().unwrap_or(Value::Null)});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_batch_insert_semantic_direct.rs (lines 26-59)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_batch_insert_semantic_direct";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_batch_insert_semantic_direct");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated direct semantic control batch insert".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let response = client
            .control
            .batch_insert(json!({
                "run_id": run_id,
                "deduplicate": true,
                "items": [
                    {
                        "item_id": "release-checkpoint-1",
                        "text": "Release checkpoint: API gateway patch r2.14 reduced 95th percentile response time from 410ms to 260ms during canary in us-east.",
                        "metadata_json": "{\"source\":\"release-engineering\",\"region\":\"us-east\",\"team\":\"gateway\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "risk-register-2",
                        "text": "Risk register update: vendor dependency for payment retries has elevated failure probability after certificate chain rotation.",
                        "metadata_json": "{\"source\":\"risk-office\",\"domain\":\"payments\",\"severity\":\"high\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "warehouse-health-3",
                        "text": "Warehouse health: lane C7 temperature deviation stabilized after recalibration; quality hold can be released after two clean cycles.",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "warehouse-health-3-duplicate",
                        "text": "Warehouse health: lane C7 temperature deviation stabilized after recalibration; quality hold can be released after two clean cycles.",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    }
                ]
            }))
            .await?;

        let count = response.get("count").and_then(Value::as_u64).unwrap_or(0);
        let node_ids = response
            .get("node_ids")
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default();
        let item_results = response
            .get("item_results")
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default();

        require(
            count >= 3,
            format!("expected at least 3 inserted items: {response}"),
        )?;
        require(
            node_ids.len() == count as usize,
            format!("node_ids mismatch: {response}"),
        )?;
        require(
            item_results.len() == 4,
            format!("item_results mismatch: {response}"),
        )?;

        let successful_items = item_results
            .iter()
            .filter(|item| {
                item.get("success")
                    .and_then(Value::as_bool)
                    .unwrap_or(false)
            })
            .count();

        require(
            successful_items >= 3,
            format!("expected at least 3 successful item inserts: {response}"),
        )?;

        let query = client
            .control
            .query(json!({
                "run_id": run_id,
                "query": "summarize release, risk, and warehouse updates for this run",
                "schema": "",
                "mode": "agent_routed",
                "direct_lane": "semantic_search",
                "include_linked_runs": false,
                "limit": 6,
                "embedding": [],
            }))
            .await?;

        require(
            query.get("mode").and_then(Value::as_str) == Some("agent_routed"),
            format!("unexpected query mode: {query}"),
        )?;
        require(
            query
                .get("final_answer")
                .and_then(Value::as_str)
                .map(str::trim)
                .map(|value| !value.is_empty())
                .unwrap_or(false),
            format!("final_answer should be non-empty: {query}"),
        )?;
        let evidence_count = query
            .get("evidence")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        require(
            evidence_count > 0,
            format!("expected non-empty evidence: {query}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "count": count,
            "successful_items": successful_items,
            "node_ids": node_ids,
            "evidence_count": evidence_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

pub async fn get_ingest_job<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/control_ingest_batch_job_lifecycle.rs (line 41)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_control_ingest_batch_job_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_control_ingest_batch");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw control ingest and batch lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client.control.ingest(json!({
            "run_id": run_id,
            "agent_id": "rust-sdk-example",
            "parallel": false,
            "items": [{
                "item_id": "incident-1",
                "content_type": "text",
                "text": "Incident SEV2-7314: cache warmer rollback restored baseline latency.",
                "payload_json": "",
                "hints_json": "{\"priority\":\"high\"}",
                "metadata_json": "{\"source\":\"ops-incident\"}"
            }]
        })).await?;
        let job_id = accepted.get("job_id").and_then(Value::as_str).ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?.to_string();

        let mut job: Option<Value> = None;
        for _ in 0..60 {
            let current = client.control.get_ingest_job(json!({"run_id": run_id, "job_id": job_id})).await?;
            if current.get("done").and_then(Value::as_bool).unwrap_or(false) { job = Some(current); break; }
            sleep(Duration::from_millis(250)).await;
        }
        let job = job.ok_or_else(|| boxed_error("timeout waiting for ingest job completion"))?;

        let batch = client.control.batch_insert(json!({
            "run_id": run_id,
            "deduplicate": true,
            "items": [
                {"item_id": "batch-1", "text": "Release checkpoint reduced p95 latency.", "metadata_json": "{\"source\":\"release\"}", "source": "rust-sdk-batch", "embedding": []},
                {"item_id": "batch-2", "text": "Warehouse QA hold can be released after clean cycles.", "metadata_json": "{\"source\":\"warehouse\"}", "source": "rust-sdk-batch", "embedding": []}
            ]
        })).await?;

        require(job.get("status").and_then(Value::as_str) == Some("completed"), format!("job should be completed: {job}"))?;
        require(batch.get("count").and_then(Value::as_u64).unwrap_or(0) >= 2, format!("expected batch inserts: {batch}"))?;

        metrics = json!({"run_id": run_id, "job_id": job_id, "batch_count": batch.get("count").cloned().unwrap_or(Value::Null)});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/control_ingest_job_lifecycle.rs (line 80)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_ingest_job_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_ingest_job_lifecycle");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control ingest job lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": format!("ingest-job-{}", run_id),
                "parallel": false,
                "items": [
                    {
                        "item_id": "incident-latency-1",
                        "content_type": "text",
                        "text": "Incident SEV2-7314 at 2026-02-14T03:22:00Z: checkout API latency in us-east rose from 180ms to 2.4s after cache warmer v1.8.1 rollout; rollback restored baseline.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"performance\"}",
                        "metadata_json": "{\"source\":\"ops-incident\",\"region\":\"us-east\",\"service\":\"checkout-api\"}",
                    },
                    {
                        "item_id": "customer-advisory-2",
                        "content_type": "text",
                        "text": "Customer advisory draft: EU enterprise tenant requested SLA clarification for batch exports; legal referenced DPA section 4.2 and retention requirement of 30 days.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"policy\"}",
                        "metadata_json": "{\"source\":\"customer-success\",\"region\":\"eu-central\",\"team\":\"legal-ops\"}",
                    },
                    {
                        "item_id": "cold-chain-telemetry-3",
                        "content_type": "text",
                        "text": "Warehouse telemetry snapshot: cold-chain lane C7 drifted from 2.1C to 6.4C for 14 minutes; sensor recalibrated and shipment placed on QA hold.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"logistics\"}",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                    }
                ],
            }))
            .await?;

        require(
            accepted
                .get("accepted")
                .and_then(Value::as_bool)
                .unwrap_or(false),
            format!("ingest not accepted: {accepted}"),
        )?;

        let job_id = accepted
            .get("job_id")
            .or_else(|| accepted.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?
            .to_string();

        let mut job: Option<Value> = None;
        for _ in 0..60 {
            let current = client
                .control
                .get_ingest_job(json!({ "run_id": run_id, "job_id": job_id }))
                .await?;
            if current
                .get("done")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                job = Some(current);
                break;
            }
            sleep(Duration::from_millis(250)).await;
        }

        let job = job.ok_or_else(|| boxed_error("timeout waiting for ingest job completion"))?;

        require(
            job.get("done").and_then(Value::as_bool).unwrap_or(false),
            format!("job should be done: {job}"),
        )?;
        require(
            job.get("status").and_then(Value::as_str) == Some("completed"),
            format!("job should be completed: {job}"),
        )?;

        let traces = job
            .get("traces")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("job traces missing: {job}")))?;
        require(!traces.is_empty(), format!("job traces missing: {job}"))?;

        let mut write_count = 0usize;
        let mut successful_writes = 0usize;
        for trace in traces {
            let writes = trace
                .get("writes")
                .and_then(Value::as_array)
                .cloned()
                .unwrap_or_default();
            write_count += writes.len();
            successful_writes += writes
                .iter()
                .filter(|write| {
                    write
                        .get("success")
                        .and_then(Value::as_bool)
                        .unwrap_or(false)
                })
                .count();
        }

        require(
            write_count > 0,
            format!("expected non-empty ingestion writes: {job}"),
        )?;
        require(
            successful_writes > 0,
            format!("expected at least one successful write: {job}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "job_id": job_id,
            "trace_count": traces.len(),
            "write_count": write_count,
            "successful_writes": successful_writes,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/control_query_agent_routed.rs (line 72)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_query_agent_routed";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_query_agent_routed");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control query agent-routed flow".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": format!("query-routed-{}", run_id),
                "parallel": false,
                "items": [
                    {
                        "item_id": "safety-incident-1",
                        "content_type": "text",
                        "text": "Safety briefing: forklift zone B had two near-miss events this week; camera review confirmed blind-spot congestion during shift handoff.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"safety\"}",
                        "metadata_json": "{\"source\":\"warehouse-safety\",\"zone\":\"B\",\"period\":\"weekly\"}",
                    },
                    {
                        "item_id": "product-telemetry-2",
                        "content_type": "text",
                        "text": "Product telemetry: onboarding completion rose from 61% to 74% after removing optional steps, but payment-link retries increased by 9%.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"product-metrics\"}",
                        "metadata_json": "{\"source\":\"product-analytics\",\"funnel\":\"onboarding\",\"metric_window\":\"7d\"}",
                    },
                    {
                        "item_id": "support-escalation-3",
                        "content_type": "text",
                        "text": "Support escalation summary: three enterprise tickets cited delayed audit log exports; root cause traced to a throttling rule on shared workers.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"customer-impact\"}",
                        "metadata_json": "{\"source\":\"support-ops\",\"segment\":\"enterprise\",\"topic\":\"audit-logs\"}",
                    }
                ],
            }))
            .await?;

        let job_id = accepted
            .get("job_id")
            .or_else(|| accepted.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?
            .to_string();

        let mut done = false;
        for _ in 0..60 {
            let current = client
                .control
                .get_ingest_job(json!({ "run_id": run_id, "job_id": job_id }))
                .await?;
            if current
                .get("done")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                done = true;
                break;
            }
            sleep(Duration::from_millis(250)).await;
        }
        require(done, "ingest job did not complete before query")?;

        let response = client
            .control
            .query(json!({
                "run_id": run_id,
                "query": "summarize the safety, product, and support signals captured for this run",
                "schema": "",
                "mode": "agent_routed",
                "direct_lane": "semantic_search",
                "include_linked_runs": false,
                "limit": 5,
                "embedding": [],
            }))
            .await?;

        require(
            response.get("mode").and_then(Value::as_str) == Some("agent_routed"),
            format!("unexpected query mode: {response}"),
        )?;
        require(
            response
                .get("routing_summary")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("routing_summary should be non-empty: {response}"),
        )?;

        let consulted_runs = response
            .get("consulted_runs")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("consulted_runs must be array: {response}")))?;
        require(
            consulted_runs
                .iter()
                .filter_map(Value::as_str)
                .any(|value| value == run_id || value.ends_with(&format!("::{run_id}"))),
            format!("consulted_runs missing primary run_id: {response}"),
        )?;

        require(
            response
                .get("final_answer")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("final_answer should be non-empty: {response}"),
        )?;

        let evidence_count = response
            .get("evidence")
            .and_then(Value::as_array)
            .map(std::vec::Vec::len)
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "job_id": job_id,
            "mode": response.get("mode").cloned().unwrap_or(Value::Null),
            "consulted_runs": consulted_runs,
            "evidence_count": evidence_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

pub async fn query<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/control_query_direct_bypass_matrix.rs (lines 21-30)

async fn run_lane(
    client: &Client,
    run_id: &str,
    query: &str,
    expect_enabled: bool,
) -> Result<Value, Box<dyn Error>> {
    let payload = client
        .control
        .query(json!({
            "run_id": run_id,
            "query": query,
            "schema": "",
            "mode": "direct_bypass",
            "direct_lane": "semantic_search",
            "include_linked_runs": false,
            "limit": 5,
            "embedding": [],
        }))
        .await;

    match payload {
        Ok(payload) => {
            require(
                expect_enabled,
                format!("direct bypass semantic lane unexpectedly succeeded: {payload}"),
            )?;
            require(
                payload.get("mode").and_then(Value::as_str) == Some("direct_bypass"),
                format!("unexpected mode payload: {payload}"),
            )?;

            Ok(json!({
                "enabled": true,
                "status": "ok",
                "mode": payload.get("mode").cloned().unwrap_or(Value::Null),
                "final_answer": payload.get("final_answer").and_then(Value::as_str).unwrap_or_default(),
            }))
        }
        Err(err) => {
            if expect_enabled {
                return Err(boxed_error(format!(
                    "direct bypass semantic lane expected enabled but failed: {err}"
                )));
            }
            let message = err.to_string();
            require(
                is_permission_denied_like(&message),
                format!("direct bypass semantic lane should fail with permission denied: {message}"),
            )?;
            Ok(json!({
                "enabled": false,
                "status": "denied",
                "message": message,
            }))
        }
    }
}

examples/control_batch_insert_semantic_direct.rs (lines 103-112)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_batch_insert_semantic_direct";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_batch_insert_semantic_direct");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated direct semantic control batch insert".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let response = client
            .control
            .batch_insert(json!({
                "run_id": run_id,
                "deduplicate": true,
                "items": [
                    {
                        "item_id": "release-checkpoint-1",
                        "text": "Release checkpoint: API gateway patch r2.14 reduced 95th percentile response time from 410ms to 260ms during canary in us-east.",
                        "metadata_json": "{\"source\":\"release-engineering\",\"region\":\"us-east\",\"team\":\"gateway\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "risk-register-2",
                        "text": "Risk register update: vendor dependency for payment retries has elevated failure probability after certificate chain rotation.",
                        "metadata_json": "{\"source\":\"risk-office\",\"domain\":\"payments\",\"severity\":\"high\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "warehouse-health-3",
                        "text": "Warehouse health: lane C7 temperature deviation stabilized after recalibration; quality hold can be released after two clean cycles.",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    },
                    {
                        "item_id": "warehouse-health-3-duplicate",
                        "text": "Warehouse health: lane C7 temperature deviation stabilized after recalibration; quality hold can be released after two clean cycles.",
                        "metadata_json": "{\"source\":\"iot-telemetry\",\"facility\":\"atl-03\",\"lane\":\"C7\"}",
                        "source": "rust-sdk-batch",
                        "embedding": [],
                    }
                ]
            }))
            .await?;

        let count = response.get("count").and_then(Value::as_u64).unwrap_or(0);
        let node_ids = response
            .get("node_ids")
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default();
        let item_results = response
            .get("item_results")
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default();

        require(
            count >= 3,
            format!("expected at least 3 inserted items: {response}"),
        )?;
        require(
            node_ids.len() == count as usize,
            format!("node_ids mismatch: {response}"),
        )?;
        require(
            item_results.len() == 4,
            format!("item_results mismatch: {response}"),
        )?;

        let successful_items = item_results
            .iter()
            .filter(|item| {
                item.get("success")
                    .and_then(Value::as_bool)
                    .unwrap_or(false)
            })
            .count();

        require(
            successful_items >= 3,
            format!("expected at least 3 successful item inserts: {response}"),
        )?;

        let query = client
            .control
            .query(json!({
                "run_id": run_id,
                "query": "summarize release, risk, and warehouse updates for this run",
                "schema": "",
                "mode": "agent_routed",
                "direct_lane": "semantic_search",
                "include_linked_runs": false,
                "limit": 6,
                "embedding": [],
            }))
            .await?;

        require(
            query.get("mode").and_then(Value::as_str) == Some("agent_routed"),
            format!("unexpected query mode: {query}"),
        )?;
        require(
            query
                .get("final_answer")
                .and_then(Value::as_str)
                .map(str::trim)
                .map(|value| !value.is_empty())
                .unwrap_or(false),
            format!("final_answer should be non-empty: {query}"),
        )?;
        let evidence_count = query
            .get("evidence")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        require(
            evidence_count > 0,
            format!("expected non-empty evidence: {query}"),
        )?;

        metrics = json!({
            "run_id": run_id,
            "count": count,
            "successful_items": successful_items,
            "node_ids": node_ids,
            "evidence_count": evidence_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/control_query_agent_routed.rs (lines 88-97)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "control_query_agent_routed";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("control_query_agent_routed");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated control query agent-routed flow".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let accepted = client
            .control
            .ingest(json!({
                "run_id": run_id,
                "agent_id": "rust-sdk-example",
                "idempotency_key": format!("query-routed-{}", run_id),
                "parallel": false,
                "items": [
                    {
                        "item_id": "safety-incident-1",
                        "content_type": "text",
                        "text": "Safety briefing: forklift zone B had two near-miss events this week; camera review confirmed blind-spot congestion during shift handoff.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"safety\"}",
                        "metadata_json": "{\"source\":\"warehouse-safety\",\"zone\":\"B\",\"period\":\"weekly\"}",
                    },
                    {
                        "item_id": "product-telemetry-2",
                        "content_type": "text",
                        "text": "Product telemetry: onboarding completion rose from 61% to 74% after removing optional steps, but payment-link retries increased by 9%.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"medium\",\"signal\":\"product-metrics\"}",
                        "metadata_json": "{\"source\":\"product-analytics\",\"funnel\":\"onboarding\",\"metric_window\":\"7d\"}",
                    },
                    {
                        "item_id": "support-escalation-3",
                        "content_type": "text",
                        "text": "Support escalation summary: three enterprise tickets cited delayed audit log exports; root cause traced to a throttling rule on shared workers.",
                        "payload_json": "",
                        "hints_json": "{\"priority\":\"high\",\"signal\":\"customer-impact\"}",
                        "metadata_json": "{\"source\":\"support-ops\",\"segment\":\"enterprise\",\"topic\":\"audit-logs\"}",
                    }
                ],
            }))
            .await?;

        let job_id = accepted
            .get("job_id")
            .or_else(|| accepted.get("jobId"))
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("ingest did not return job_id: {accepted}")))?
            .to_string();

        let mut done = false;
        for _ in 0..60 {
            let current = client
                .control
                .get_ingest_job(json!({ "run_id": run_id, "job_id": job_id }))
                .await?;
            if current
                .get("done")
                .and_then(Value::as_bool)
                .unwrap_or(false)
            {
                done = true;
                break;
            }
            sleep(Duration::from_millis(250)).await;
        }
        require(done, "ingest job did not complete before query")?;

        let response = client
            .control
            .query(json!({
                "run_id": run_id,
                "query": "summarize the safety, product, and support signals captured for this run",
                "schema": "",
                "mode": "agent_routed",
                "direct_lane": "semantic_search",
                "include_linked_runs": false,
                "limit": 5,
                "embedding": [],
            }))
            .await?;

        require(
            response.get("mode").and_then(Value::as_str) == Some("agent_routed"),
            format!("unexpected query mode: {response}"),
        )?;
        require(
            response
                .get("routing_summary")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("routing_summary should be non-empty: {response}"),
        )?;

        let consulted_runs = response
            .get("consulted_runs")
            .and_then(Value::as_array)
            .ok_or_else(|| boxed_error(format!("consulted_runs must be array: {response}")))?;
        require(
            consulted_runs
                .iter()
                .filter_map(Value::as_str)
                .any(|value| value == run_id || value.ends_with(&format!("::{run_id}"))),
            format!("consulted_runs missing primary run_id: {response}"),
        )?;

        require(
            response
                .get("final_answer")
                .and_then(Value::as_str)
                .map(|value| !value.trim().is_empty())
                .unwrap_or(false),
            format!("final_answer should be non-empty: {response}"),
        )?;

        let evidence_count = response
            .get("evidence")
            .and_then(Value::as_array)
            .map(std::vec::Vec::len)
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "job_id": job_id,
            "mode": response.get("mode").cloned().unwrap_or(Value::Null),
            "consulted_runs": consulted_runs,
            "evidence_count": evidence_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

pub async fn diagnose<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn delete_run<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/support/utils.rs (line 90)

pub async fn cleanup_run(client: &Client, run_id: &str) -> bool {
    let control_ok = client
        .control
        .delete_run(json!({ "run_id": run_id }))
        .await
        .is_ok();
    let core_ok = match client.core.delete_run(json!({ "run_id": run_id })).await {
        Ok(_) => true,
        Err(err) => is_permission_denied_like(&err.to_string()),
    };
    control_ok && core_ok
}

pub async fn reflect<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn lessons<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/lessons_lifecycle.rs (line 35)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_lessons_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_lessons_lifecycle");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw lessons lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut remember = RememberOptions::new("Always verify the stored deductible before approving reimbursement.");
        remember.run_id = Some(run_id.clone());
        remember.intent = Some("lesson".into());
        remember.lesson_type = Some("success".into());
        remember.lesson_scope = Some("session".into());
        client.remember(remember).await?;

        let mut lessons = serde_json::Value::Null;
        for _ in 0..24 {
            let current = client
                .control
                .lessons(json!({"run_id": run_id, "limit": 10}))
                .await?;
            let has_lesson = current
                .get("lessons")
                .and_then(|v| v.as_array())
                .map(|items| !items.is_empty())
                .unwrap_or(false);
            lessons = current;
            if has_lesson {
                break;
            }
            sleep(Duration::from_millis(500)).await;
        }
        let lesson_id = lessons.get("lessons").and_then(|v| v.as_array()).and_then(|items| items.iter().find_map(|item| item.get("id").and_then(|v| v.as_str()))).ok_or_else(|| boxed_error(format!("expected lesson in lifecycle test: {lessons}")))?.to_string();
        let deleted = client.control.delete_lesson(json!({"lesson_id": lesson_id})).await?;
        let remaining = client.control.lessons(json!({"run_id": run_id, "limit": 10})).await?;
        require(deleted.get("success").and_then(Value::as_bool).unwrap_or(true), format!("delete_lesson failed: {deleted}"))?;
        require(!remaining.get("lessons").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(lesson_id.as_str()))).unwrap_or(false), format!("lesson still present after delete: {remaining}"))?;
        metrics = json!({"run_id": run_id, "lesson_id": lesson_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/helper_mas_learning_loop.rs (line 59)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "helper_mas_learning_loop";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("helper_mas_learning_loop");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated helper MAS checkpoint/outcome/strategies flow".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut register = RegisterAgentOptions::new("planner");
        register.run_id = Some(run_id.clone());
        register.role = "planner".to_string();
        register.read_scopes = vec!["rule".to_string(), "lesson".to_string(), "fact".to_string()];
        register.write_scopes = vec!["lesson".to_string(), "trace".to_string()];
        register.shared_memory_lanes = vec!["knowledge".to_string(), "history".to_string()];
        client.register_agent(register).await?;

        let mut remember = RememberOptions::new(
            "If a retry succeeds after token signer rotation, record it as a reusable recovery pattern.",
        );
        remember.run_id = Some(run_id.clone());
        remember.agent_id = Some("planner".to_string());
        remember.intent = Some("lesson".to_string());
        remember.lesson_type = Some("success".to_string());
        remember.lesson_scope = Some("session".to_string());
        remember.lesson_importance = Some("high".to_string());
        client.remember(remember).await?;

        let mut checkpoint = CheckpointOptions::new(
            "Planner isolated the recovery path to token signer rotation.",
        );
        checkpoint.run_id = Some(run_id.clone());
        checkpoint.label = Some("pre-compaction-1".to_string());
        checkpoint.metadata = Some(json!({ "stage": "analysis" }));
        checkpoint.agent_id = Some("planner".to_string());
        let checkpoint_response = client.checkpoint(checkpoint).await?;

        let mut list_agents = ListAgentsOptions::default();
        list_agents.run_id = Some(run_id.clone());
        let agents = client.list_agents(list_agents).await?;

        let lessons = client.control.lessons(json!({ "run_id": run_id, "limit": 10 })).await?;
        let lesson_id = lessons
            .get("lessons")
            .and_then(|value| value.as_array())
            .and_then(|items| items.first())
            .and_then(|item| item.get("id"))
            .and_then(|value| value.as_str())
            .ok_or_else(|| boxed_error(format!("expected at least one lesson to record outcome against: {lessons}")))?
            .to_string();

        let mut outcome = RecordOutcomeOptions::new(lesson_id, "success");
        outcome.run_id = Some(run_id.clone());
        outcome.signal = 0.75;
        outcome.rationale = "Recovery succeeded after following the stored lesson.".to_string();
        outcome.agent_id = Some("planner".to_string());
        let outcome_response = client.record_outcome(outcome).await?;

        let mut strategies = SurfaceStrategiesOptions::default();
        strategies.run_id = Some(run_id.clone());
        strategies.lesson_types = vec!["success".to_string(), "failure".to_string()];
        strategies.max_strategies = 5;
        let strategy_response = client.surface_strategies(strategies).await?;

        require(
            checkpoint_response
                .get("success")
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
            format!("checkpoint failed: {checkpoint_response}"),
        )?;
        let agent_count = agents
            .get("agents")
            .and_then(|value| value.as_array())
            .map(|items| items.len())
            .unwrap_or(0);
        require(agent_count == 1, format!("agent registration missing: {agents}"))?;
        require(
            outcome_response
                .get("success")
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
            format!("record_outcome failed: {outcome_response}"),
        )?;
        let strategy_count = strategy_response
            .get("strategies")
            .and_then(|value| value.as_array())
            .map(|items| items.len())
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "checkpoint_id": checkpoint_response.get("checkpoint_id").cloned().unwrap_or(serde_json::Value::Null),
            "agent_count": agent_count,
            "strategy_count": strategy_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/public/03_checkpoint_reflect_outcome.rs (line 59)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "public_03_checkpoint_reflect_outcome";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("public_03_checkpoint_reflect_outcome");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated helper MAS checkpoint/outcome/strategies flow".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut register = RegisterAgentOptions::new("planner");
        register.run_id = Some(run_id.clone());
        register.role = "planner".to_string();
        register.read_scopes = vec!["rule".to_string(), "lesson".to_string(), "fact".to_string()];
        register.write_scopes = vec!["lesson".to_string(), "trace".to_string()];
        register.shared_memory_lanes = vec!["knowledge".to_string(), "history".to_string()];
        client.register_agent(register).await?;

        let mut remember = RememberOptions::new(
            "If a retry succeeds after token signer rotation, record it as a reusable recovery pattern.",
        );
        remember.run_id = Some(run_id.clone());
        remember.agent_id = Some("planner".to_string());
        remember.intent = Some("lesson".to_string());
        remember.lesson_type = Some("success".to_string());
        remember.lesson_scope = Some("session".to_string());
        remember.lesson_importance = Some("high".to_string());
        client.remember(remember).await?;

        let mut checkpoint = CheckpointOptions::new(
            "Planner isolated the recovery path to token signer rotation.",
        );
        checkpoint.run_id = Some(run_id.clone());
        checkpoint.label = Some("pre-compaction-1".to_string());
        checkpoint.metadata = Some(json!({ "stage": "analysis" }));
        checkpoint.agent_id = Some("planner".to_string());
        let checkpoint_response = client.checkpoint(checkpoint).await?;

        let mut list_agents = ListAgentsOptions::default();
        list_agents.run_id = Some(run_id.clone());
        let agents = client.list_agents(list_agents).await?;

        let lessons = client.control.lessons(json!({ "run_id": run_id, "limit": 10 })).await?;
        let lesson_id = lessons
            .get("lessons")
            .and_then(|value| value.as_array())
            .and_then(|items| items.first())
            .and_then(|item| item.get("id"))
            .and_then(|value| value.as_str())
            .ok_or_else(|| boxed_error(format!("expected at least one lesson to record outcome against: {lessons}")))?
            .to_string();

        let mut outcome = RecordOutcomeOptions::new(lesson_id, "success");
        outcome.run_id = Some(run_id.clone());
        outcome.signal = 0.75;
        outcome.rationale = "Recovery succeeded after following the stored lesson.".to_string();
        outcome.agent_id = Some("planner".to_string());
        let outcome_response = client.record_outcome(outcome).await?;

        let mut strategies = SurfaceStrategiesOptions::default();
        strategies.run_id = Some(run_id.clone());
        strategies.lesson_types = vec!["success".to_string(), "failure".to_string()];
        strategies.max_strategies = 5;
        let strategy_response = client.surface_strategies(strategies).await?;

        require(
            checkpoint_response
                .get("success")
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
            format!("checkpoint failed: {checkpoint_response}"),
        )?;
        let agent_count = agents
            .get("agents")
            .and_then(|value| value.as_array())
            .map(|items| items.len())
            .unwrap_or(0);
        require(agent_count == 1, format!("agent registration missing: {agents}"))?;
        require(
            outcome_response
                .get("success")
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
            format!("record_outcome failed: {outcome_response}"),
        )?;
        let strategy_count = strategy_response
            .get("strategies")
            .and_then(|value| value.as_array())
            .map(|items| items.len())
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "checkpoint_id": checkpoint_response.get("checkpoint_id").cloned().unwrap_or(serde_json::Value::Null),
            "agent_count": agent_count,
            "strategy_count": strategy_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/public/09_user_scoping_and_isolation.rs (line 44)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "public_09_user_scoping_and_isolation";
    let started = Instant::now();
    let client = create_client().await?;
    let user_a = "sdk-user-a".to_string();
    let user_b = "sdk-user-b".to_string();
    let seed_run = new_run_id("public_user_scope_seed");
    let allowed_run = new_run_id("public_user_scope_allowed");
    let blocked_run = new_run_id("public_user_scope_blocked");
    client.set_transport(TransportMode::Http);
    client.set_run_id(Some(seed_run.clone()));

    let mut passed = true;
    let mut detail = "validated user scoping and same-user cross-run reuse".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut lesson = RememberOptions::new("When a claim is missing a city, check the original intake note before escalating.");
        lesson.run_id = Some(seed_run.clone());
        lesson.user_id = Some(user_a.clone());
        lesson.agent_id = Some("planner".into());
        lesson.intent = Some("lesson".into());
        lesson.lesson_type = Some("success".into());
        lesson.lesson_scope = Some("global".into());
        lesson.lesson_importance = Some("high".into());
        lesson.metadata = Some(json!({"source": "public-example", "family": "user-scope"}));
        let lesson_write = client.remember(lesson).await?;

        let mut lessons = serde_json::Value::Null;
        for _ in 0..24 {
            let current = client
                .control
                .lessons(json!({"run_id": seed_run, "user_id": user_a, "limit": 10}))
                .await?;
            let has_lesson = current
                .get("lessons")
                .and_then(|v| v.as_array())
                .map(|items| !items.is_empty())
                .unwrap_or(false);
            lessons = current;
            if has_lesson {
                break;
            }
            sleep(Duration::from_millis(500)).await;
        }
        let lesson_id = lessons.get("lessons").and_then(|v| v.as_array()).and_then(|items| items.iter().find_map(|item| item.get("id").and_then(|v| v.as_str()))).ok_or_else(|| boxed_error(format!("expected lesson for isolation scenario: {lessons}")))?.to_string();

        let mut allowed = RecallOptions::new(
            "A claim is missing a city. Before escalating, what note should I check?",
        );
        allowed.run_id = Some(allowed_run.clone());
        allowed.user_id = Some(user_a.clone());
        allowed.entry_types = vec!["lesson".into()];
        allowed.limit = 10;
        let allowed_response = client.recall(allowed).await?;

        let mut blocked = RecallOptions::new(
            "A claim is missing a city. Before escalating, what note should I check?",
        );
        blocked.run_id = Some(blocked_run.clone());
        blocked.user_id = Some(user_b.clone());
        blocked.entry_types = vec!["lesson".into()];
        blocked.limit = 10;
        let blocked_response = client.recall(blocked).await?;

        let allowed_text = format!("{} {}",
            allowed_response.get("final_answer").and_then(|v| v.as_str()).unwrap_or(""),
            allowed_response.get("evidence").and_then(|v| v.as_array()).map(|items| items.iter().filter_map(|item| item.get("content").and_then(|v| v.as_str())).collect::<Vec<_>>().join(" ")).unwrap_or_default()
        ).to_lowercase();
        let blocked_text = format!("{} {}",
            blocked_response.get("final_answer").and_then(|v| v.as_str()).unwrap_or(""),
            blocked_response.get("evidence").and_then(|v| v.as_array()).map(|items| items.iter().filter_map(|item| item.get("content").and_then(|v| v.as_str())).collect::<Vec<_>>().join(" ")).unwrap_or_default()
        ).to_lowercase();

        require(lesson_write.get("accepted").and_then(|v| v.as_bool()).unwrap_or(false) || lesson_write.get("job_id").is_some(), format!("lesson write failed: {lesson_write}"))?;
        require(allowed_text.contains("original intake note"), format!("same-user cross-run lesson reuse failed: {allowed_response}"))?;
        require(!blocked_text.contains("original intake note"), format!("cross-user leak detected: {blocked_response}"))?;

        metrics = json!({
            "seed_run": seed_run,
            "allowed_run": allowed_run,
            "blocked_run": blocked_run,
            "lesson_id": lesson_id,
            "allowed_evidence_count": allowed_response.get("evidence").and_then(|v| v.as_array()).map(|items| items.len()).unwrap_or(0),
            "blocked_evidence_count": blocked_response.get("evidence").and_then(|v| v.as_array()).map(|items| items.len()).unwrap_or(0),
        });
        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let mut cleanup_ok = true;
    for run_id in [&seed_run, &allowed_run, &blocked_run] {
        cleanup_ok = cleanup_ok && cleanup_run(&client, run_id).await;
    }
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/public/10_full_learning_loop_smoke.rs (line 130)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "public_10_full_learning_loop_smoke";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("public_10_full_learning_loop_smoke");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated all helper flows".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut remember = RememberOptions::new("Policy limit is 5000 and claimant city is Leeds.");
        remember.run_id = Some(run_id.clone());
        remember.agent_id = Some("planner".to_string());
        remember.intent = Some("fact".to_string());
        remember.metadata = Some(json!({"suite": "all-helpers", "family": "claims"}));
        remember.importance = Some("high".to_string());
        remember.occurrence_time = Some(std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64 - 86400);
        let remember_response = client.remember(remember).await?;

        let mut lesson = RememberOptions::new("If city is missing from the latest step, check stored claim facts before escalating.");
        lesson.run_id = Some(run_id.clone());
        lesson.agent_id = Some("planner".to_string());
        lesson.intent = Some("lesson".to_string());
        lesson.lesson_type = Some("success".to_string());
        lesson.lesson_scope = Some("session".to_string());
        lesson.lesson_importance = Some("high".to_string());
        let lesson_response = client.remember(lesson).await?;

        let mut mental_model = RememberOptions::new(
            "Claims case overview: Policy limit 5000 GBP, claimant city Leeds, \
             missing-city branch resolved via stored claim facts. Lesson: check stored facts before escalating.",
        );
        mental_model.run_id = Some(run_id.clone());
        mental_model.agent_id = Some("planner".to_string());
        mental_model.intent = Some("mental_model".to_string());
        mental_model.importance = Some("critical".to_string());
        mental_model.metadata = Some(json!({"suite": "all-helpers", "entity": "claims-case", "consolidated": true}));
        let mental_model_response = client.remember(mental_model).await?;

        let mut recall = RecallOptions::new("What is the policy limit?");
        recall.run_id = Some(run_id.clone());
        recall.agent_id = Some("planner".to_string());
        recall.limit = 5;
        let recall_response = client.recall(recall).await?;

        let mut context = GetContextOptions::default();
        context.run_id = Some(run_id.clone());
        context.query = Some("Prepare a short adjuster summary".to_string());
        context.agent_id = Some("planner".to_string());
        context.limit = Some(6);
        context.max_token_budget = Some(700);
        let context_response = client.get_context(context).await?;

        let mut health = MemoryHealthOptions::default();
        health.run_id = Some(run_id.clone());
        health.limit = 50;
        let health_response = client.memory_health(health).await?;

        let mut diagnose = DiagnoseOptions::new("policy limit lookup returned empty");
        diagnose.run_id = Some(run_id.clone());
        diagnose.error_type = Some("retrieval".to_string());
        diagnose.limit = 5;
        let diagnose_response = client.diagnose(diagnose).await?;

        let mut reflect = ReflectOptions::default();
        reflect.run_id = Some(run_id.clone());
        let reflect_response = client.reflect(reflect).await?;

        let mut register = RegisterAgentOptions::new("planner");
        register.run_id = Some(run_id.clone());
        register.role = "planner".to_string();
        register.read_scopes = vec!["fact".into(), "lesson".into(), "rule".into(), "mental_model".into(), "archive_block".into(), "handoff".into(), "feedback".into()];
        register.write_scopes = vec!["fact".into(), "trace".into(), "lesson".into(), "observation".into(), "archive_block".into()];
        register.shared_memory_lanes = vec!["knowledge".into(), "history".into()];
        let register_response = client.register_agent(register).await?;

        let mut list_agents = ListAgentsOptions::default();
        list_agents.run_id = Some(run_id.clone());
        let agents_response = client.list_agents(list_agents).await?;

        let mut archive = ArchiveOptions::new(
            "Exact adjuster note: claimant confirmed city is Leeds during triage.",
            "adjuster_note",
        );
        archive.run_id = Some(run_id.clone());
        archive.agent_id = Some("planner".to_string());
        archive.origin_agent_id = Some("planner".to_string());
        archive.source_attempt_id = Some("attempt-1".to_string());
        archive.source_tool = Some("phone_call".to_string());
        archive.labels = vec!["claims".to_string(), "triage".to_string()];
        archive.family = Some("claims-adjustment".to_string());
        archive.metadata = Some(json!({"case": "all-helpers"}));
        let archive_response = client.archive(archive).await?;
        let reference_id = archive_response
            .get("reference_id")
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("archive reference missing: {archive_response}")))?
            .to_string();

        let mut dereference = DereferenceOptions::new(reference_id.clone());
        dereference.run_id = Some(run_id.clone());
        dereference.agent_id = Some("planner".to_string());
        let dereference_response = client.dereference(dereference).await?;

        let mut checkpoint = CheckpointOptions::new("Planner captured claim facts before window compaction.");
        checkpoint.run_id = Some(run_id.clone());
        checkpoint.label = Some("pre-compaction".to_string());
        checkpoint.metadata = Some(json!({"stage": "analysis"}));
        checkpoint.agent_id = Some("planner".to_string());
        let checkpoint_response = client.checkpoint(checkpoint).await?;

        let lessons_response = client.control.lessons(json!({"run_id": run_id, "limit": 20})).await?;
        let lesson_id = lessons_response
            .get("lessons")
            .and_then(Value::as_array)
            .and_then(|items| items.iter().find_map(|item| item.get("id").and_then(Value::as_str)))
            .ok_or_else(|| boxed_error(format!("expected lesson id for outcome flow: {lessons_response}")))?
            .to_string();

        let mut outcome = RecordOutcomeOptions::new(lesson_id, "success");
        outcome.run_id = Some(run_id.clone());
        outcome.signal = 0.75;
        outcome.rationale = "Planner reused stored claim fact and resolved the missing-city branch.".to_string();
        outcome.agent_id = Some("planner".to_string());
        let outcome_response = client.record_outcome(outcome).await?;

        let mut strategies = SurfaceStrategiesOptions::default();
        strategies.run_id = Some(run_id.clone());
        strategies.lesson_types = vec!["success".to_string(), "rule".to_string()];
        strategies.max_strategies = 5;
        let strategies_response = client.surface_strategies(strategies).await?;

        let mut handoff = HandoffOptions::new(
            "claim-1",
            "planner",
            "reviewer",
            "Review whether the stored claimant city is sufficient for routing.",
        );
        handoff.run_id = Some(run_id.clone());
        handoff.requested_action = "review".to_string();
        handoff.metadata = Some(json!({"team": "claims"}));
        let handoff_response = client.handoff(handoff).await?;
        let handoff_id = handoff_response
            .get("handoff_id")
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("handoff id missing: {handoff_response}")))?
            .to_string();

        let mut feedback = FeedbackOptions::new(handoff_id.clone(), "approve");
        feedback.run_id = Some(run_id.clone());
        feedback.comments = "Stored fact is sufficient; proceed without escalation.".to_string();
        feedback.from_agent_id = Some("reviewer".to_string());
        feedback.metadata = Some(json!({"team": "claims"}));
        let feedback_response = client.feedback(feedback).await?;

        require(remember_response.get("job_id").is_some() || remember_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("remember failed: {remember_response}"))?;
        require(mental_model_response.get("job_id").is_some() || mental_model_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("mental_model remember failed: {mental_model_response}"))?;
        require(lesson_response.get("job_id").is_some() || lesson_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("lesson remember failed: {lesson_response}"))?;
        require(recall_response.get("final_answer").is_some() || recall_response.get("evidence").is_some(), format!("recall failed: {recall_response}"))?;
        require(context_response.get("sources").and_then(Value::as_array).is_some(), format!("context malformed: {context_response}"))?;
        require(health_response.get("entry_counts").and_then(Value::as_object).is_some(), format!("memory_health malformed: {health_response}"))?;
        require(diagnose_response.get("failure_lessons").and_then(Value::as_array).is_some(), format!("diagnose malformed: {diagnose_response}"))?;
        require(reflect_response.get("lessons").and_then(Value::as_array).is_some(), format!("reflect malformed: {reflect_response}"))?;
        require(register_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("register_agent failed: {register_response}"))?;
        require(agents_response.get("agents").and_then(Value::as_array).map(|items| !items.is_empty()).unwrap_or(false), format!("list_agents failed: {agents_response}"))?;
        require(archive_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("archive failed: {archive_response}"))?;
        require(dereference_response.get("found").and_then(Value::as_bool).unwrap_or(false), format!("dereference failed: {dereference_response}"))?;
        require(checkpoint_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("checkpoint failed: {checkpoint_response}"))?;
        require(outcome_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("record_outcome failed: {outcome_response}"))?;
        require(strategies_response.get("strategies").and_then(Value::as_array).is_some(), format!("surface_strategies malformed: {strategies_response}"))?;
        require(handoff_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("handoff failed: {handoff_response}"))?;
        require(feedback_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("feedback failed: {feedback_response}"))?;

        let strategy_count = strategies_response
            .get("strategies")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        let agent_count = agents_response
            .get("agents")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        let lesson_count = lessons_response
            .get("lessons")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "agent_count": agent_count,
            "strategy_count": strategy_count,
            "reference_id": reference_id,
            "lesson_count": lesson_count,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

examples/helper_all_helpers.rs (line 118)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "helper_all_helpers";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("helper_all_helpers");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated all helper flows".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut remember = RememberOptions::new("Policy limit is 5000 and claimant city is Leeds.");
        remember.run_id = Some(run_id.clone());
        remember.agent_id = Some("planner".to_string());
        remember.intent = Some("fact".to_string());
        remember.metadata = Some(json!({"suite": "all-helpers", "family": "claims"}));
        remember.importance = Some("high".to_string());
        let remember_response = client.remember(remember).await?;

        let mut lesson = RememberOptions::new("If city is missing from the latest step, check stored claim facts before escalating.");
        lesson.run_id = Some(run_id.clone());
        lesson.agent_id = Some("planner".to_string());
        lesson.intent = Some("lesson".to_string());
        lesson.lesson_type = Some("success".to_string());
        lesson.lesson_scope = Some("session".to_string());
        lesson.lesson_importance = Some("high".to_string());
        let lesson_response = client.remember(lesson).await?;

        let mut recall = RecallOptions::new("What is the policy limit?");
        recall.run_id = Some(run_id.clone());
        recall.agent_id = Some("planner".to_string());
        recall.limit = 5;
        let recall_response = client.recall(recall).await?;

        let mut context = GetContextOptions::default();
        context.run_id = Some(run_id.clone());
        context.query = Some("Prepare a short adjuster summary".to_string());
        context.agent_id = Some("planner".to_string());
        context.limit = Some(6);
        context.max_token_budget = Some(700);
        let context_response = client.get_context(context).await?;

        let mut health = MemoryHealthOptions::default();
        health.run_id = Some(run_id.clone());
        health.limit = 50;
        let health_response = client.memory_health(health).await?;

        let mut diagnose = DiagnoseOptions::new("policy limit lookup returned empty");
        diagnose.run_id = Some(run_id.clone());
        diagnose.error_type = Some("retrieval".to_string());
        diagnose.limit = 5;
        let diagnose_response = client.diagnose(diagnose).await?;

        let mut reflect = ReflectOptions::default();
        reflect.run_id = Some(run_id.clone());
        let reflect_response = client.reflect(reflect).await?;

        let mut register = RegisterAgentOptions::new("planner");
        register.run_id = Some(run_id.clone());
        register.role = "planner".to_string();
        register.read_scopes = vec!["fact".into(), "lesson".into(), "rule".into(), "archive_block".into(), "handoff".into(), "feedback".into()];
        register.write_scopes = vec!["fact".into(), "trace".into(), "lesson".into(), "observation".into(), "archive_block".into()];
        register.shared_memory_lanes = vec!["knowledge".into(), "history".into()];
        let register_response = client.register_agent(register).await?;

        let mut list_agents = ListAgentsOptions::default();
        list_agents.run_id = Some(run_id.clone());
        let agents_response = client.list_agents(list_agents).await?;

        let mut archive = ArchiveOptions::new(
            "Exact adjuster note: claimant confirmed city is Leeds during triage.",
            "adjuster_note",
        );
        archive.run_id = Some(run_id.clone());
        archive.agent_id = Some("planner".to_string());
        archive.origin_agent_id = Some("planner".to_string());
        archive.source_attempt_id = Some("attempt-1".to_string());
        archive.source_tool = Some("phone_call".to_string());
        archive.labels = vec!["claims".to_string(), "triage".to_string()];
        archive.family = Some("claims-adjustment".to_string());
        archive.metadata = Some(json!({"case": "all-helpers"}));
        let archive_response = client.archive(archive).await?;
        let reference_id = archive_response
            .get("reference_id")
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("archive reference missing: {archive_response}")))?
            .to_string();

        let mut dereference = DereferenceOptions::new(reference_id.clone());
        dereference.run_id = Some(run_id.clone());
        dereference.agent_id = Some("planner".to_string());
        let dereference_response = client.dereference(dereference).await?;

        let mut checkpoint = CheckpointOptions::new("Planner captured claim facts before window compaction.");
        checkpoint.run_id = Some(run_id.clone());
        checkpoint.label = Some("pre-compaction".to_string());
        checkpoint.metadata = Some(json!({"stage": "analysis"}));
        checkpoint.agent_id = Some("planner".to_string());
        let checkpoint_response = client.checkpoint(checkpoint).await?;

        let lessons_response = client.control.lessons(json!({"run_id": run_id, "limit": 20})).await?;
        let lesson_id = lessons_response
            .get("lessons")
            .and_then(Value::as_array)
            .and_then(|items| items.iter().find_map(|item| item.get("id").and_then(Value::as_str)))
            .ok_or_else(|| boxed_error(format!("expected lesson id for outcome flow: {lessons_response}")))?
            .to_string();

        let mut outcome = RecordOutcomeOptions::new(lesson_id, "success");
        outcome.run_id = Some(run_id.clone());
        outcome.signal = 0.75;
        outcome.rationale = "Planner reused stored claim fact and resolved the missing-city branch.".to_string();
        outcome.agent_id = Some("planner".to_string());
        let outcome_response = client.record_outcome(outcome).await?;

        let mut strategies = SurfaceStrategiesOptions::default();
        strategies.run_id = Some(run_id.clone());
        strategies.lesson_types = vec!["success".to_string(), "rule".to_string()];
        strategies.max_strategies = 5;
        let strategies_response = client.surface_strategies(strategies).await?;

        let mut handoff = HandoffOptions::new(
            "claim-1",
            "planner",
            "reviewer",
            "Review whether the stored claimant city is sufficient for routing.",
        );
        handoff.run_id = Some(run_id.clone());
        handoff.requested_action = "review".to_string();
        handoff.metadata = Some(json!({"team": "claims"}));
        let handoff_response = client.handoff(handoff).await?;
        let handoff_id = handoff_response
            .get("handoff_id")
            .and_then(Value::as_str)
            .ok_or_else(|| boxed_error(format!("handoff id missing: {handoff_response}")))?
            .to_string();

        let mut feedback = FeedbackOptions::new(handoff_id.clone(), "approve");
        feedback.run_id = Some(run_id.clone());
        feedback.comments = "Stored fact is sufficient; proceed without escalation.".to_string();
        feedback.from_agent_id = Some("reviewer".to_string());
        feedback.metadata = Some(json!({"team": "claims"}));
        let feedback_response = client.feedback(feedback).await?;

        let scratch_run = format!("{run_id}_forget");
        let mut scratch = RememberOptions::new("Scratch run for forget helper coverage.");
        scratch.run_id = Some(scratch_run.clone());
        scratch.agent_id = Some("planner".to_string());
        scratch.intent = Some("fact".to_string());
        scratch.metadata = Some(json!({"suite": "all-helpers", "temporary": true}));
        let scratch_response = client.remember(scratch).await?;

        let forget_response = client
            .forget(ForgetOptions::for_run(scratch_run.clone()))
            .await?;

        let mut forgotten = RecallOptions::new("What temporary scratch fact exists?");
        forgotten.run_id = Some(scratch_run.clone());
        forgotten.limit = 3;
        let forgotten_response = client.recall(forgotten).await?;

        require(remember_response.get("job_id").is_some() || remember_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("remember failed: {remember_response}"))?;
        require(lesson_response.get("job_id").is_some() || lesson_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("lesson remember failed: {lesson_response}"))?;
        require(recall_response.get("final_answer").is_some() || recall_response.get("evidence").is_some(), format!("recall failed: {recall_response}"))?;
        require(context_response.get("sources").and_then(Value::as_array).is_some(), format!("context malformed: {context_response}"))?;
        require(health_response.get("entry_counts").and_then(Value::as_object).is_some(), format!("memory_health malformed: {health_response}"))?;
        require(diagnose_response.get("failure_lessons").and_then(Value::as_array).is_some(), format!("diagnose malformed: {diagnose_response}"))?;
        require(reflect_response.get("lessons").and_then(Value::as_array).is_some(), format!("reflect malformed: {reflect_response}"))?;
        require(register_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("register_agent failed: {register_response}"))?;
        require(agents_response.get("agents").and_then(Value::as_array).map(|items| !items.is_empty()).unwrap_or(false), format!("list_agents failed: {agents_response}"))?;
        require(archive_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("archive failed: {archive_response}"))?;
        require(dereference_response.get("found").and_then(Value::as_bool).unwrap_or(false), format!("dereference failed: {dereference_response}"))?;
        require(checkpoint_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("checkpoint failed: {checkpoint_response}"))?;
        require(outcome_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("record_outcome failed: {outcome_response}"))?;
        require(strategies_response.get("strategies").and_then(Value::as_array).is_some(), format!("surface_strategies malformed: {strategies_response}"))?;
        require(handoff_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("handoff failed: {handoff_response}"))?;
        require(feedback_response.get("success").and_then(Value::as_bool).unwrap_or(false), format!("feedback failed: {feedback_response}"))?;
        require(scratch_response.get("job_id").is_some() || scratch_response.get("accepted").and_then(Value::as_bool).unwrap_or(false), format!("scratch remember failed: {scratch_response}"))?;
        require(forget_response.get("success").and_then(Value::as_bool).unwrap_or(true), format!("forget failed: {forget_response}"))?;
        let scratch_fact_visible = forgotten_response
            .get("evidence")
            .and_then(Value::as_array)
            .map(|items| {
                items.iter().any(|item| {
                    item.get("run_id").and_then(Value::as_str) == Some(scratch_run.as_str())
                        || item
                            .get("content")
                            .and_then(Value::as_str)
                            .map(|content| {
                                content
                                    .to_ascii_lowercase()
                                    .contains("scratch run for forget helper coverage")
                            })
                            .unwrap_or(false)
                })
            })
            .unwrap_or(false);
        require(!scratch_fact_visible, format!("scratch fact should be forgotten even if same-user lessons still surface: {forgotten_response}"))?;

        let strategy_count = strategies_response
            .get("strategies")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        let agent_count = agents_response
            .get("agents")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        let lesson_count = lessons_response
            .get("lessons")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);

        metrics = json!({
            "run_id": run_id,
            "agent_count": agent_count,
            "strategy_count": strategy_count,
            "reference_id": reference_id,
            "lesson_count": lesson_count,
            "forgotten_run": scratch_run,
        });

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);

    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn delete_lesson<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/internal/lessons_lifecycle.rs (line 49)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_lessons_lifecycle";
    let started = Instant::now();
    let client = create_client().await?;
    let run_id = new_run_id("internal_lessons_lifecycle");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);
    let mut passed = true;
    let mut detail = "validated raw lessons lifecycle".to_string();
    let mut metrics = json!({});

    let scenario = async {
        let mut remember = RememberOptions::new("Always verify the stored deductible before approving reimbursement.");
        remember.run_id = Some(run_id.clone());
        remember.intent = Some("lesson".into());
        remember.lesson_type = Some("success".into());
        remember.lesson_scope = Some("session".into());
        client.remember(remember).await?;

        let mut lessons = serde_json::Value::Null;
        for _ in 0..24 {
            let current = client
                .control
                .lessons(json!({"run_id": run_id, "limit": 10}))
                .await?;
            let has_lesson = current
                .get("lessons")
                .and_then(|v| v.as_array())
                .map(|items| !items.is_empty())
                .unwrap_or(false);
            lessons = current;
            if has_lesson {
                break;
            }
            sleep(Duration::from_millis(500)).await;
        }
        let lesson_id = lessons.get("lessons").and_then(|v| v.as_array()).and_then(|items| items.iter().find_map(|item| item.get("id").and_then(|v| v.as_str()))).ok_or_else(|| boxed_error(format!("expected lesson in lifecycle test: {lessons}")))?.to_string();
        let deleted = client.control.delete_lesson(json!({"lesson_id": lesson_id})).await?;
        let remaining = client.control.lessons(json!({"run_id": run_id, "limit": 10})).await?;
        require(deleted.get("success").and_then(Value::as_bool).unwrap_or(true), format!("delete_lesson failed: {deleted}"))?;
        require(!remaining.get("lessons").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(lesson_id.as_str()))).unwrap_or(false), format!("lesson still present after delete: {remaining}"))?;
        metrics = json!({"run_id": run_id, "lesson_id": lesson_id});
        Ok::<(), Box<dyn Error>>(())
    }.await;

    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
    if passed { Ok(()) } else { Err(boxed_error(detail)) }
}

pub async fn context<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn archive_block<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn dereference<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn memory_health<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn checkpoint<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn list_agents<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn create_handoff<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn submit_feedback<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn record_outcome<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn surface_strategies<T: Serialize>( &self, payload: T, ) -> Result<Value>

impl ControlClient

pub async fn subscribe<T: Serialize>(&self, payload: T) -> Result<ValueStream>

Trait Implementations

impl Clone for ControlClient

fn clone(&self) -> ControlClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.