link-assistant-router 1.0.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
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
127
128
129
130
131
132
133
134
135
136
137

use std::collections::BTreeSet;

use crate::route_contract::{
    ListenerKind, RouteAuth, RouteClass, RouteId, ServiceKind, endpoint_base, management_endpoint,
    route_for_path, route_specs,
};

#[test]
fn every_registered_route_has_one_canonical_class_and_listener_contract() {
    let specs = route_specs();
    let unique = specs
        .iter()
        .map(|spec| (spec.method.as_str(), spec.template, spec.listeners))
        .collect::<BTreeSet<_>>();
    assert_eq!(unique.len(), specs.len(), "duplicate route contract");

    for spec in specs {
        assert!(
            spec.template.starts_with("/api/"),
            "non-canonical route: {}",
            spec.template
        );
        match spec.class {
            RouteClass::Neutral => {
                assert_eq!(spec.template, "/api/health");
                assert_eq!(spec.auth, RouteAuth::None);
            }
            RouteClass::Management => {
                assert!(spec.template.starts_with("/api/management/"));
                if matches!(
                    spec.id,
                    RouteId::AdminStatus | RouteId::AdminBootstrap | RouteId::AdminBootstrapConfirm
                ) {
                    assert_eq!(spec.auth, RouteAuth::None);
                } else {
                    assert_eq!(spec.auth, RouteAuth::Admin);
                }
            }
            RouteClass::Service(service) => {
                assert!(spec.template.starts_with("/api/services/"));
                if service == ServiceKind::ActivityPub {
                    assert_eq!(spec.auth, RouteAuth::None);
                } else {
                    assert_eq!(spec.auth, RouteAuth::Client);
                }
            }
        }
    }
}

#[test]
fn canonical_endpoint_builders_treat_saved_servers_as_origins() {
    for origin in ["https://router.example", "https://router.example/"] {
        assert_eq!(
            endpoint_base(origin, ServiceKind::Anthropic),
            "https://router.example/api/services/anthropic"
        );
        assert_eq!(
            endpoint_base(origin, ServiceKind::OpenAi),
            "https://router.example/api/services/openai/v1"
        );
        assert_eq!(
            endpoint_base(origin, ServiceKind::Codex),
            "https://router.example/api/services/codex/v1"
        );
        assert_eq!(
            endpoint_base(origin, ServiceKind::Qwen),
            "https://router.example/api/services/qwen/v1"
        );
        assert_eq!(
            endpoint_base(origin, ServiceKind::Gemini),
            "https://router.example/api/services/gemini"
        );
        assert_eq!(
            management_endpoint(origin, RouteId::Tokens),
            "https://router.example/api/management/tokens"
        );
    }
}

#[test]
fn listener_eligibility_is_a_security_boundary() {
    let health = route_for_path(&http::Method::GET, "/api/health").unwrap();
    assert!(health.listeners.contains(&ListenerKind::Combined));
    assert!(health.listeners.contains(&ListenerKind::InferenceOnly));

    let management = route_for_path(&http::Method::GET, "/api/management/tokens").unwrap();
    assert!(management.listeners.contains(&ListenerKind::Combined));
    assert!(management.listeners.contains(&ListenerKind::Admin));
    assert!(!management.listeners.contains(&ListenerKind::InferenceOnly));

    let anthropic =
        route_for_path(&http::Method::POST, "/api/services/anthropic/v1/messages").unwrap();
    assert!(anthropic.listeners.contains(&ListenerKind::Combined));
    assert!(anthropic.listeners.contains(&ListenerKind::InferenceOnly));
    assert!(!anthropic.listeners.contains(&ListenerKind::Admin));

    let github = route_for_path(&http::Method::POST, "/api/services/github/api/graphql").unwrap();
    assert_eq!(github.class, RouteClass::Service(ServiceKind::GitHub));
    assert!(!github.listeners.contains(&ListenerKind::InferenceOnly));
}

#[test]
fn removed_paths_have_no_route_contract() {
    for (method, path) in [
        (http::Method::GET, "/health"),
        (http::Method::GET, "/health/subscriptions"),
        (http::Method::POST, "/v1/messages"),
        (http::Method::POST, "/v1/chat/completions"),
        (http::Method::GET, "/v1/models"),
        (http::Method::POST, "/api/anthropic/v1/messages"),
        (http::Method::POST, "/api/openai/v1/responses"),
        (http::Method::POST, "/api/codex/v1/responses"),
        (http::Method::POST, "/api/qwen/v1/chat/completions"),
        (http::Method::GET, "/api/gemini/v1beta/models"),
        (
            http::Method::POST,
            "/api/vertex/v1/projects/p/locations/l/models/m:rawPredict",
        ),
        (http::Method::POST, "/invoke"),
        (http::Method::GET, "/api/tokens"),
        (http::Method::GET, "/api/providers"),
        (http::Method::POST, "/api/login"),
        (http::Method::GET, "/api/admin/status"),
        (http::Method::GET, "/metrics"),
        (http::Method::GET, "/api/v3/user"),
        (http::Method::POST, "/api/graphql"),
        (http::Method::GET, "/user"),
        (http::Method::POST, "/git/owner/repo.git/git-upload-pack"),
        (http::Method::GET, "/actor/code"),
    ] {
        assert!(
            route_for_path(&method, path).is_none(),
            "removed route still classified: {method} {path}"
        );
    }
}