bitrouter 1.0.0-alpha.34

BitRouter: an LLM API router. CLI + assembly library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::*;

#[tokio::test]
async fn assembled_revision_serves_pinned_routes_and_withdraws_inherited_adoption() -> Result<()> {
    let fixture = fixture(false).await?;
    let runtime = &fixture.assembled.evolution;
    runtime
        .register("local", definition("coding", "candidate"))
        .await?;
    let service = runtime.service("local")?;
    service.set_mode(EvolutionMode::Manual, None).await?;
    adopt_fixture(runtime).await?;
    let original = service
        .state()
        .await?
        .blocks
        .get("coding-block")
        .context("missing original")?
        .clone();
    let old = session(&fixture, "before-revision", "fixture").await?;
    let pipeline = fixture
        .assembled
        .app
        .language_model()
        .context("pipeline missing")?;
    pipeline
        .execute(request(&old, "old-request", "coding")?)
        .await?;
    let mut revised = original.definition.clone();
    revised.rules[0].baseline_route = "candidate".into();
    revised.rules[0].challenger_route = "coding".into();
    runtime
        .revise("local", revised, original.experiment_id.clone())
        .await?;
    let current = service
        .state()
        .await?
        .blocks
        .get("coding-block")
        .context("missing current")?
        .clone();
    let fresh = session(&fixture, "after-revision", "fixture").await?;
    pipeline
        .execute(request(&old, "old-after-revision", "coding")?)
        .await?;
    pipeline
        .execute(request(&fresh, "new-after-revision", "coding")?)
        .await?;
    let old_execution = runtime
        .executions(&old)
        .await?
        .pop()
        .context("missing old execution")?;
    assert_eq!(old_execution.dispatch_route, "candidate");
    assert_eq!(
        old_execution
            .settlement
            .context("missing old settlement")?
            .hops[0]
            .model,
        "cheap"
    );
    let enrollment = service
        .enrollment(&fresh)
        .await?
        .context("missing new enrollment")?;
    let assignment = enrollment
        .assignments
        .get("coding-block")
        .context("missing new assignment")?;
    assert_eq!(assignment.experiment_id, current.experiment_id);
    let new_execution = runtime
        .executions(&fresh)
        .await?
        .pop()
        .context("missing new execution")?;
    assert_eq!(
        new_execution
            .settlement
            .context("missing new settlement")?
            .hops[0]
            .model,
        if assignment.arm == Arm::Challenger {
            "strong"
        } else {
            "cheap"
        }
    );
    let archived = runtime
        .reconcile_experiment("local", "coding-block", Some(&original.experiment_id))
        .await?;
    assert!(archived.archived && archived.published);
    assert_eq!(
        archived.block_status,
        BlockStatus::RolledBack,
        "unresolved evidence does not support the arranged adoption"
    );
    for (identity, id) in [(&old, "withdrawn-old"), (&fresh, "withdrawn-new")] {
        pipeline.execute(request(identity, id, "coding")?).await?;
        let execution = runtime
            .executions(identity)
            .await?
            .pop()
            .context("missing withdrawn execution")?;
        assert_eq!(execution.dispatch_route, "coding");
        assert_eq!(
            execution
                .settlement
                .context("missing withdrawn settlement")?
                .hops[0]
                .model,
            "strong"
        );
    }
    assert_eq!(
        service
            .state()
            .await?
            .blocks
            .get("coding-block")
            .context("missing current")?
            .status,
        BlockStatus::RolledBack
    );
    Ok(())
}