Struct QueuedLlmPolicy 

pub struct QueuedLlmPolicy { /* private fields */ }

Implementations

impl QueuedLlmPolicy

pub fn new( id: impl Into<String>, version: impl Into<String>, model: LlmModelIdentity, ) -> QueuedLlmPolicy

Examples found in repository

examples/uncertainty_resolution.rs (lines 191-199)

fn llm_interface_branch() -> Result<(), Box<dyn std::error::Error>> {
    let mut canwu = Canwu::demo(202)?;
    let ticket_id = DecisionTicketId::new(2);
    enqueue_ticket(
        &mut canwu,
        ticket_id,
        10,
        DecisionControllerBinding::new(
            "law-llm-controller",
            DecisionPolicyIdentity::new(DecisionPolicyKind::Llm, "strict-law-selector", "1"),
            DecisionAuthority::Actor {
                actor: Canwu::demo_ids().commander,
            },
        ),
    )?;
    let mut policy = QueuedLlmPolicy::new(
        "strict-law-selector",
        "1",
        LlmModelIdentity {
            provider: "not-connected".to_owned(),
            model: "host-selected-model".to_owned(),
            prompt_contract: "return one existing option_id and no new action".to_owned(),
        },
    );
    let ticket = canwu.decision_ticket(ticket_id).expect("LLM ticket");
    let request = policy.external_request(ticket);
    println!("llm_request={}", serde_json::to_string(&request)?);

    // A real host sends `request` to its model and parses a strict structured
    // answer. This example supplies the same response object without making a
    // network call.
    policy.submit(
        ticket_id,
        ExternalDecisionResponse {
            ticket_version: request.ticket_version,
            option_id: "pass".to_owned(),
            provider: "not-connected".to_owned(),
            request_id: "example-response-1".to_owned(),
            metadata: BTreeMap::new(),
        },
    )?;
    let evaluation = canwu.drive_decision(
        canwu.time(),
        0,
        DecisionRequestId::new(12),
        None,
        ticket_id,
        &policy,
    )?;
    assert!(matches!(evaluation, DecisionEvaluation::Prepared(_)));
    canwu.step_canonical()?.expect("LLM decision boundary");
    Ok(())
}

pub fn submit( &mut self, ticket_id: DecisionTicketId, response: ExternalDecisionResponse, ) -> Result<(), DecisionError>

Examples found in repository

examples/uncertainty_resolution.rs (lines 207-216)

fn llm_interface_branch() -> Result<(), Box<dyn std::error::Error>> {
    let mut canwu = Canwu::demo(202)?;
    let ticket_id = DecisionTicketId::new(2);
    enqueue_ticket(
        &mut canwu,
        ticket_id,
        10,
        DecisionControllerBinding::new(
            "law-llm-controller",
            DecisionPolicyIdentity::new(DecisionPolicyKind::Llm, "strict-law-selector", "1"),
            DecisionAuthority::Actor {
                actor: Canwu::demo_ids().commander,
            },
        ),
    )?;
    let mut policy = QueuedLlmPolicy::new(
        "strict-law-selector",
        "1",
        LlmModelIdentity {
            provider: "not-connected".to_owned(),
            model: "host-selected-model".to_owned(),
            prompt_contract: "return one existing option_id and no new action".to_owned(),
        },
    );
    let ticket = canwu.decision_ticket(ticket_id).expect("LLM ticket");
    let request = policy.external_request(ticket);
    println!("llm_request={}", serde_json::to_string(&request)?);

    // A real host sends `request` to its model and parses a strict structured
    // answer. This example supplies the same response object without making a
    // network call.
    policy.submit(
        ticket_id,
        ExternalDecisionResponse {
            ticket_version: request.ticket_version,
            option_id: "pass".to_owned(),
            provider: "not-connected".to_owned(),
            request_id: "example-response-1".to_owned(),
            metadata: BTreeMap::new(),
        },
    )?;
    let evaluation = canwu.drive_decision(
        canwu.time(),
        0,
        DecisionRequestId::new(12),
        None,
        ticket_id,
        &policy,
    )?;
    assert!(matches!(evaluation, DecisionEvaluation::Prepared(_)));
    canwu.step_canonical()?.expect("LLM decision boundary");
    Ok(())
}

Trait Implementations

impl Clone for QueuedLlmPolicy

fn clone(&self) -> QueuedLlmPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueuedLlmPolicy

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

Formats the value using the given formatter.

impl DecisionPolicy for QueuedLlmPolicy

fn identity(&self) -> &DecisionPolicyIdentity

fn decide( &self, ticket: &DecisionTicket, ) -> Result<PolicyDecision, DecisionError>

impl ExternalPolicy for QueuedLlmPolicy

fn submitted_response( &self, ticket: &DecisionTicket, ) -> Option<ExternalDecisionResponse>

fn external_request(&self, ticket: &DecisionTicket) -> ExternalDecisionRequest

impl LlmPolicy for QueuedLlmPolicy

fn model_identity(&self) -> &LlmModelIdentity