Struct Decisions 

pub struct Decisions { /* private fields */ }

A bank of questions asked of a decision model against the rolling conversation.

Guards name the questions ({"decided": "confirmed"}, see crate::flow::decided); the runtime asks the ones the flow can act on at each decision point, in one request, and records each answer under decision:{id} with the caller turn it is about. An answer counts only for that turn, so nothing is latched and nothing has to be cleared when the caller corrects themselves: the next ask reads the correction.

use std::sync::Arc;
use gemini_adk_rs::decision::{Answer, Decision, Decisions, MockDecisionModel, Question};

let model = Arc::new(MockDecisionModel::new(|_| {
    Ok([("confirmed".to_string(), Answer::boolean(0.97))].into())
}));
let decisions = Decisions::new(model).question(
    "confirmed",
    Decision::new(Question::boolean(
        "In their last turn, did the caller agree to the booking that was read back?",
    )),
);
assert!(decisions.get("confirmed").is_some());

Implementations

impl Decisions

pub fn new(model: Arc<dyn DecisionModel>) -> Self

An empty bank over model.

pub fn question(self, id: impl Into<String>, decision: Decision) -> Self

Declare a question.

pub fn standing<S: Into<String>>(self, ids: impl IntoIterator<Item = S>) -> Self

Ask these questions at every caller turn, whatever the flow needs: questions read outside the flow, by phase transitions or patterns.

pub fn history_turns(self, turns: usize) -> Self

How many turns the decision model reads (default 40).

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

How long an ask waits for the model (default 2 s). A slow or failed ask records its questions unsure, so guards on them do not hold.

pub fn bank(&self) -> &BTreeMap<String, Decision>

The declared questions.

pub fn get(&self, id: &str) -> Option<&Decision>

One declared question.

pub fn history_len(&self) -> usize

How many turns the decision model reads.

pub fn model_id(&self) -> &str

The model’s identifier.

pub fn select(&self, scope: &DecisionScope) -> BTreeSet<String>

The questions worth asking at a turn’s end for scope: the declared ones it names, the standing ones, and those that write a key it reads.

pub fn governing(&self, scope: &DecisionScope) -> BTreeSet<String>

The questions scope itself depends on: the declared ones it names and those that write a key it reads, without the standing ones. What a tool call waits for before it is admitted.

pub async fn ask( &self, ids: &BTreeSet<String>, conversation: &Conversation, state: &State, ) -> Round

Ask ids about conversation and record the answers in state.

A question already answered in state for the conversation’s caller turn is not asked again; one recorded unsure because the model could not be asked (or had no options to offer) is. With no caller words yet, nothing is asked. The bank holds no session state, so one bank can serve many sessions.

Trait Implementations

impl Debug for Decisions

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

Formats the value using the given formatter.