terraphim_router 1.16.33

Unified routing engine for LLM and Agent providers
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

//! Integration tests for unified routing

use std::path::PathBuf;
use terraphim_router::{Router, RoutingContext};
use terraphim_types::capability::{Capability, CostLevel, Provider, ProviderType};

#[test]
fn test_route_to_llm_provider() {
    let mut router = Router::new();

    let llm = Provider::new(
        "gpt-4",
        "GPT-4",
        ProviderType::Llm {
            model_id: "gpt-4".to_string(),
            api_endpoint: "https://api.openai.com".to_string(),
        },
        vec![Capability::DeepThinking],
    );

    router.add_provider(llm);

    let decision = router
        .route(
            "Think deeply about system design",
            &RoutingContext::default(),
        )
        .unwrap();

    assert_eq!(decision.provider.id, "gpt-4");
    assert!(decision
        .matched_capabilities
        .contains(&Capability::DeepThinking));
}

#[test]
fn test_route_to_agent_provider() {
    let mut router = Router::new();

    let agent = Provider::new(
        "@codex",
        "Codex",
        ProviderType::Agent {
            agent_id: "@codex".to_string(),
            cli_command: "opencode".to_string(),
            working_dir: PathBuf::from("/tmp"),
        },
        vec![Capability::CodeGeneration],
    );

    router.add_provider(agent);

    let decision = router
        .route("Implement a function", &RoutingContext::default())
        .unwrap();

    assert_eq!(decision.provider.id, "@codex");
    assert!(matches!(
        decision.provider.provider_type,
        ProviderType::Agent { .. }
    ));
}

#[test]
fn test_capability_based_selection() {
    let mut router = Router::new();

    // Cheap agent for code generation
    let agent = Provider::new(
        "@codex",
        "Codex",
        ProviderType::Agent {
            agent_id: "@codex".to_string(),
            cli_command: "opencode".to_string(),
            working_dir: PathBuf::from("/tmp"),
        },
        vec![Capability::CodeGeneration],
    )
    .with_cost(CostLevel::Cheap);

    // Expensive LLM for deep thinking
    let llm = Provider::new(
        "claude-opus",
        "Claude Opus",
        ProviderType::Llm {
            model_id: "claude-3-opus".to_string(),
            api_endpoint: "https://api.anthropic.com".to_string(),
        },
        vec![Capability::DeepThinking, Capability::CodeGeneration],
    )
    .with_cost(CostLevel::Expensive);

    router.add_provider(agent);
    router.add_provider(llm);

    // Deep thinking task should route to LLM
    let decision = router
        .route(
            "Think deeply about architecture",
            &RoutingContext::default(),
        )
        .unwrap();
    assert_eq!(decision.provider.id, "claude-opus");

    // Code generation could go to either, but agent is cheaper
    let decision = router
        .route("Implement a function", &RoutingContext::default())
        .unwrap();
    // With CostOptimized strategy, should pick cheaper option
    assert_eq!(decision.provider.cost_level, CostLevel::Cheap);
}