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}