sim-lib-openai-server 0.1.1

OpenAI-compatible gateway skeleton for SIM.
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use sim_kernel::{Expr, Symbol};

/// Static description of a plan combinator: its name and structural constraints.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PlanCombinator {
    /// Combinator name without the `plan/` prefix (for example `race`).
    pub name: &'static str,
    /// Minimum number of child plans the combinator accepts.
    pub min_children: usize,
    /// Maximum number of child plans the combinator accepts.
    pub max_children: usize,
    /// Keyword argument names the combinator recognizes.
    pub keywords: &'static [&'static str],
    /// Whether the combinator can be executed by the current evaluator.
    pub executable_now: bool,
}

/// Returns the full table of known plan combinators.
pub fn plan_combinators() -> &'static [PlanCombinator] {
    &PLAN_COMBINATORS
}

/// Returns the combinator table encoded as a list of map [`Expr`] records.
pub fn plan_combinators_expr() -> Expr {
    Expr::List(PLAN_COMBINATORS.iter().map(plan_combinator_expr).collect())
}

/// Returns the `plan/<name>` head symbol for a combinator name.
pub fn plan_symbol(name: &str) -> Symbol {
    Symbol::new(format!("plan/{name}"))
}

/// Looks up a combinator by its name, returning `None` if it is not known.
pub fn combinator_by_name(name: &str) -> Option<&'static PlanCombinator> {
    PLAN_COMBINATORS
        .iter()
        .find(|combinator| combinator.name == name)
}

fn plan_combinator_expr(combinator: &PlanCombinator) -> Expr {
    Expr::Map(vec![
        field("name", Expr::Symbol(plan_symbol(combinator.name))),
        field(
            "min-children",
            Expr::String(combinator.min_children.to_string()),
        ),
        field(
            "max-children",
            Expr::String(combinator.max_children.to_string()),
        ),
        field(
            "keywords",
            Expr::List(
                combinator
                    .keywords
                    .iter()
                    .map(|keyword| Expr::Symbol(Symbol::new(*keyword)))
                    .collect(),
            ),
        ),
        field("executable-now", Expr::Bool(combinator.executable_now)),
    ])
}

use sim_value::build::entry as field;

const PLAN_COMBINATORS: [PlanCombinator; 12] = [
    PlanCombinator {
        name: "atom",
        min_children: 1,
        max_children: 1,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "race",
        min_children: 1,
        max_children: 4,
        keywords: &["deadline"],
        executable_now: true,
    },
    PlanCombinator {
        name: "market",
        min_children: 1,
        max_children: 1,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "verify",
        min_children: 2,
        max_children: 2,
        keywords: &["on-fail"],
        executable_now: true,
    },
    PlanCombinator {
        name: "debate",
        min_children: 2,
        max_children: 4,
        keywords: &["judge", "rounds"],
        executable_now: true,
    },
    PlanCombinator {
        name: "chain",
        min_children: 1,
        max_children: 4,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "fallback",
        min_children: 1,
        max_children: 4,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "cache",
        min_children: 1,
        max_children: 1,
        keywords: &["mode", "ttl"],
        executable_now: true,
    },
    PlanCombinator {
        name: "budget",
        min_children: 1,
        max_children: 1,
        keywords: &["max-cost", "max-latency-ms", "max-tokens"],
        executable_now: true,
    },
    PlanCombinator {
        name: "local",
        min_children: 1,
        max_children: 1,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "remote",
        min_children: 1,
        max_children: 1,
        keywords: &[],
        executable_now: true,
    },
    PlanCombinator {
        name: "trace",
        min_children: 1,
        max_children: 1,
        keywords: &[],
        executable_now: true,
    },
];