link-assistant-router 1.14.2

Link.Assistant.Router — Claude MAX OAuth proxy and token gateway for Anthropic APIs
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

use super::*;

#[test]
fn exact_model_authority_is_durable_and_survives_rotation() {
    let mgr = test_manager();
    let policy = crate::model_contract::ModelAccessPolicy {
        allowed_models: vec!["provider/model-a".into(), "provider/model-b".into()],
        allow_substitution: true,
        substitution_source: Some("unit test opt-in".into()),
    };
    let token = mgr
        .issue_ephemeral_with_model_policy(
            &IssueRequest {
                ttl_hours: 1,
                label: "pinned-run",
                account: Some("primary"),
                client_kind: Some("codex"),
                principal_id: Some("primary"),
                ..IssueRequest::default()
            },
            &policy,
        )
        .unwrap();
    let claims = mgr.validate_token(&token).unwrap();
    assert_eq!(mgr.model_policy_for(&claims.sub).unwrap(), policy);
    assert!(mgr.authorize_model(&claims.sub, "provider/model-a").is_ok());
    let denied = mgr
        .authorize_model(&claims.sub, "provider/model-c")
        .unwrap_err();
    assert_eq!(denied.code, "model_not_allowed");
    assert_eq!(denied.allowed_models, policy.allowed_models);

    let rotated = mgr
        .rotate_token_with(&claims.sub, &RotateOverrides::default())
        .unwrap();
    let rotated_claims = mgr.validate_token(&rotated).unwrap();
    assert_eq!(mgr.model_policy_for(&rotated_claims.sub).unwrap(), policy);
}

#[test]
fn missing_model_authority_fails_closed() {
    let mgr = test_manager();

    assert!(matches!(
        mgr.model_policy_for("missing-token-id"),
        Err(TokenError::NotFound(id)) if id == "missing-token-id"
    ));
    let denied = mgr
        .authorize_model("missing-token-id", "provider/model-a")
        .unwrap_err();
    assert_eq!(denied.code, "model_policy_unavailable");
    assert_eq!(denied.requested_model, "provider/model-a");
    assert!(denied.allowed_models.is_empty());
}

#[test]
fn run_leases_are_explicit_and_legacy_ephemeral_tokens_stay_unknown() {
    let manager = test_manager();
    let request = IssueRequest {
        ttl_hours: 1,
        label: "idle-wrapper",
        account: Some("primary"),
        client_kind: Some("codex"),
        principal_id: Some("primary"),
        ..IssueRequest::default()
    };
    let policy = crate::model_contract::ModelAccessPolicy {
        allowed_models: vec!["gpt-current".into()],
        ..crate::model_contract::ModelAccessPolicy::default()
    };

    let leased = manager
        .issue_ephemeral_with_model_policy_and_run_lease(&request, &policy)
        .expect("issue leased wrapper token");
    let leased_id = manager.validate_token(&leased).unwrap().sub;
    let initial = manager
        .list_tokens()
        .unwrap()
        .into_iter()
        .find(|record| record.id == leased_id)
        .unwrap()
        .run_lease_expires_at
        .expect("new wrapper token carries a lease");
    let renewed = manager
        .renew_run_lease(&leased_id)
        .expect("a live wrapper can renew its lease");
    assert!(renewed >= initial);

    let legacy = manager
        .issue_ephemeral_with_model_policy(&request, &policy)
        .expect("issue legacy-shaped ephemeral token");
    let legacy_id = manager.validate_token(&legacy).unwrap().sub;
    assert!(
        manager.renew_run_lease(&legacy_id).is_err(),
        "an absent lease is unknown, never silently promoted to live"
    );
}