xonecas.io
79113
Ma

mini-coding-agent / files

mini-coding-agent / src / models.zig

10.1 KB
1const std = @import("std");
2const platform = @import("platform.zig");
3const modelsdev = @import("models_dev.zig");
4const http = @import("http.zig");
5const config = @import("config.zig");
6
7pub const Thinking = enum { off, budget, effort };
8
9pub const Model = struct {
10    id: []const u8,
11    api: []const u8,
12    provider: []const u8,
13    base_url: []const u8,
14    api_key: ?[]const u8,
15    effort: []const u8,
16    supports_images: bool,
17    context_window: u64,
18    max_tokens: u64,
19    cost_input: f64,
20    cost_output: f64,
21    cost_cache_read: f64,
22    session_header: ?[]const u8,
23    headers: []const [2][]const u8 = &.{},
24    thinking: Thinking = .budget,
25};
26
27const Builtin = struct {
28    id: []const u8,
29    session_header: ?[]const u8 = null,
30};
31
32const builtins = [_]Builtin{
33    .{ .id = "opencode", .session_header = "x-opencode-session" },
34    .{ .id = "opencode-go", .session_header = "x-opencode-session" },
35    .{ .id = "openrouter" },
36};
37
38const ladder = [_][]const u8{ "off", "minimal", "low", "medium", "high", "xhigh", "max" };
39
40fn rank(value: []const u8) i32 {
41    for (ladder, 0..) |level, i| {
42        if (std.mem.eql(u8, level, value)) return @intCast(i);
43    }
44    return -1;
45}
46
47fn normalizeEffort(value: []const u8) []const u8 {
48    return if (std.mem.eql(u8, value, "none")) "off" else value;
49}
50
51fn clampEffort(reasoning: bool, effort: []const []const u8, desired: ?[]const u8) []const u8 {
52    const want = desired orelse return "";
53    if (!reasoning) return "off";
54    if (effort.len == 0) return want;
55    for (effort) |accepted| {
56        if (std.mem.eql(u8, normalizeEffort(accepted), want)) return normalizeEffort(accepted);
57    }
58    const want_rank = rank(want);
59    if (want_rank < 0) return normalizeEffort(effort[0]);
60
61    var up: ?[]const u8 = null;
62    var down: ?[]const u8 = null;
63    for (effort) |accepted| {
64        const r = rank(normalizeEffort(accepted));
65        if (r < 0) continue;
66        if (r >= want_rank) {
67            if (up == null or r < rank(up.?)) up = accepted;
68        } else if (down == null or r > rank(down.?)) {
69            down = accepted;
70        }
71    }
72    const pick = up orelse down orelse return "off";
73    return normalizeEffort(pick);
74}
75
76fn thinkingStyle(info: modelsdev.Info) Thinking {
77    if (!info.reasoning) return .off;
78    if (info.budget_tokens) return .budget;
79    if (info.effort.len > 0) return .effort;
80    return .budget;
81}
82
83fn builtin(id: []const u8) ?*const Builtin {
84    for (&builtins) |*b| {
85        if (std.mem.eql(u8, b.id, id)) return b;
86    }
87    return null;
88}
89
90fn custom(cfg: *const config.Config, id: []const u8) ?*const config.CustomProvider {
91    for (cfg.custom_providers) |*p| {
92        if (std.mem.eql(u8, p.id, id)) return p;
93    }
94    return null;
95}
96
97fn customModel(cfg: *const config.Config, provider_id: []const u8, model_id: []const u8) ?*const config.CustomModel {
98    if (builtin(provider_id) != null) return null;
99    const p = custom(cfg, provider_id) orelse return null;
100    for (p.models) |*m| {
101        if (std.mem.eql(u8, m.id, model_id)) return m;
102    }
103    return null;
104}
105
106fn firstEnv(keys: []const []const u8) ?[]const u8 {
107    for (keys) |key| {
108        if (platform.getEnv(key)) |value| {
109            if (value.len > 0) return value;
110        }
111    }
112    return null;
113}
114
115pub fn resolve(a: std.mem.Allocator, cfg: *const config.Config, err: *?[]const u8) ?Model {
116    const provider_id = cfg.provider orelse return null;
117    const model_id = cfg.model orelse return null;
118    return resolveNamed(a, cfg, provider_id, model_id, err);
119}
120
121pub fn resolveNamed(a: std.mem.Allocator, cfg: *const config.Config, provider_id: []const u8, model_id: []const u8, err: *?[]const u8) ?Model {
122    if (builtin(provider_id)) |b| {
123        var db = modelsdev.Db.open(a) catch {
124            err.* = "model metadata unavailable";
125            return null;
126        };
127        const p = db.provider(provider_id) orelse {
128            err.* = unknownProvider(a, provider_id);
129            return null;
130        };
131        const info = db.info(provider_id, model_id) orelse {
132            err.* = unknownModel(a, model_id, provider_id);
133            return null;
134        };
135        return Model{
136            .id = model_id,
137            .api = info.api,
138            .provider = provider_id,
139            .base_url = info.base_url,
140            .api_key = firstEnv(p.env),
141            .effort = clampEffort(info.reasoning, info.effort, cfg.thinking_effort),
142            .supports_images = info.images,
143            .context_window = info.context,
144            .max_tokens = info.max_output,
145            .thinking = thinkingStyle(info),
146            .cost_input = info.cost_input,
147            .cost_output = info.cost_output,
148            .cost_cache_read = info.cost_cache_read,
149            .session_header = b.session_header,
150        };
151    }
152
153    if (custom(cfg, provider_id)) |p| {
154        const m = customModel(cfg, provider_id, model_id) orelse {
155            err.* = unknownModel(a, model_id, provider_id);
156            return null;
157        };
158        return Model{
159            .id = m.id,
160            .api = @tagName(m.api),
161            .provider = provider_id,
162            .base_url = m.baseUrl,
163            .api_key = firstEnv(p.envKeys),
164            .effort = clampEffort(m.reasoning, m.effort, cfg.thinking_effort),
165            .supports_images = m.images,
166            .context_window = m.context,
167            .max_tokens = m.maxOutput,
168            .cost_input = m.cost[0],
169            .cost_output = m.cost[1],
170            .cost_cache_read = m.cost[2],
171            .session_header = null,
172            .headers = headerPairs(a, p.headers),
173        };
174    }
175
176    err.* = unknownProvider(a, provider_id);
177    return null;
178}
179
180fn headerPairs(a: std.mem.Allocator, headers: ?std.json.ArrayHashMap([]const u8)) []const [2][]const u8 {
181    const h = headers orelse return &.{};
182    var out: std.ArrayList([2][]const u8) = .empty;
183    var it = h.map.iterator();
184    while (it.next()) |e| out.append(a, .{ e.key_ptr.*, e.value_ptr.* }) catch {};
185    return out.toOwnedSlice(a) catch &.{};
186}
187
188const ProviderEntry = struct { id: []const u8, name: []const u8, ready: bool };
189
190fn usable(p: modelsdev.Provider) bool {
191    return firstEnv(p.env) != null;
192}
193
194pub fn providers(a: std.mem.Allocator, cfg: *const config.Config) []ProviderEntry {
195    var out: std.ArrayList(ProviderEntry) = .empty;
196    var db: ?modelsdev.Db = modelsdev.Db.open(a) catch null;
197    for (builtins) |b| {
198        const p = (if (db) |*d| d.provider(b.id) else null) orelse continue;
199        out.append(a, .{
200            .id = b.id,
201            .name = if (p.name.len > 0) p.name else b.id,
202            .ready = usable(p),
203        }) catch {};
204    }
205    for (cfg.custom_providers) |p| {
206        out.append(a, .{ .id = p.id, .name = p.name orelse p.id, .ready = p.envKeys.len == 0 or firstEnv(p.envKeys) != null }) catch {};
207    }
208    return out.toOwnedSlice(a) catch &.{};
209}
210
211pub const Entry = struct { id: []const u8, name: []const u8 };
212
213pub fn listing(
214    a: std.mem.Allocator,
215    cfg: *const config.Config,
216    provider_id: []const u8,
217    cancel: *const std.atomic.Value(bool),
218) ![]Entry {
219    if (custom(cfg, provider_id)) |p| return customListing(a, p);
220    if (builtin(provider_id) == null) return error.UnknownProvider;
221    var db = modelsdev.Db.open(a) catch return error.ModelMetadataUnavailable;
222    const p = db.provider(provider_id) orelse return error.UnknownProvider;
223    const base = db.baseUrl(provider_id) orelse return error.UnknownProvider;
224    const key = firstEnv(p.env) orelse return error.MissingApiKey;
225
226    const url = try std.fmt.allocPrint(a, "{s}/models", .{base});
227    const authorization = try std.fmt.allocPrint(a, "Bearer {s}", .{key});
228    const body = try http.get(a, url, &.{.{ .name = "Authorization", .value = authorization }}, cancel, .{});
229
230    const parsed = try std.json.parseFromSliceLeaky(Listed, a, body, .{ .ignore_unknown_fields = true });
231    var out: std.ArrayList(Entry) = .empty;
232    for (parsed.data orelse &.{}) |item| {
233        const id = item.id orelse continue;
234        const info = db.info(provider_id, id) orelse continue;
235        try out.append(a, .{ .id = id, .name = info.name });
236    }
237    const items = try out.toOwnedSlice(a);
238    std.mem.sort(Entry, items, {}, entryLess);
239    return items;
240}
241
242const Listed = struct {
243    data: ?[]const Item = null,
244
245    const Item = struct {
246        id: ?[]const u8 = null,
247    };
248};
249
250fn entryLess(_: void, a: Entry, b: Entry) bool {
251    return std.mem.order(u8, a.id, b.id) == .lt;
252}
253
254fn customListing(a: std.mem.Allocator, p: *const config.CustomProvider) ![]Entry {
255    var out: std.ArrayList(Entry) = .empty;
256    for (p.models) |m| try out.append(a, .{ .id = m.id, .name = m.name orelse m.id });
257    const items = try out.toOwnedSlice(a);
258    std.mem.sort(Entry, items, {}, entryLess);
259    return items;
260}
261
262fn levels(reasoning: bool, effort: []const []const u8) []const []const u8 {
263    if (!reasoning) return &.{"off"};
264    return if (effort.len == 0) &ladder else effort;
265}
266
267pub fn supportedLevels(a: std.mem.Allocator, cfg: *const config.Config, provider_id: []const u8, model_id: []const u8) []const []const u8 {
268    if (customModel(cfg, provider_id, model_id)) |m| return levels(m.reasoning, m.effort);
269    var db = modelsdev.Db.open(a) catch return &ladder;
270    const info = db.info(provider_id, model_id) orelse return &ladder;
271    return levels(info.reasoning, info.effort);
272}
273
274pub fn clampNamed(a: std.mem.Allocator, cfg: *const config.Config, provider_id: []const u8, model_id: []const u8, desired: []const u8) []const u8 {
275    if (customModel(cfg, provider_id, model_id)) |m| return clampEffort(m.reasoning, m.effort, desired);
276    var db = modelsdev.Db.open(a) catch return desired;
277    const info = db.info(provider_id, model_id) orelse return desired;
278    return clampEffort(info.reasoning, info.effort, desired);
279}
280
281fn unknownModel(a: std.mem.Allocator, model_id: []const u8, provider_id: []const u8) []const u8 {
282    return std.fmt.allocPrint(a, "unknown model \"{s}\" for provider \"{s}\"", .{ model_id, provider_id }) catch "unknown model";
283}
284
285fn unknownProvider(a: std.mem.Allocator, provider_id: []const u8) []const u8 {
286    return std.fmt.allocPrint(a, "unknown provider \"{s}\"", .{provider_id}) catch "unknown provider";
287}