79113
Ma
mini-coding-agent / files
mini-coding-agent / src / http.zig
11.6 KB
1const std = @import("std"); 2const platform = @import("platform.zig"); 3const time = @import("time.zig"); 4const build_options = @import("build_options"); 5 6const user_agent = "mini-coding-agent/" ++ build_options.version; 7 8const openrouter_headers = [_]std.http.Header{ 9 .{ .name = "HTTP-Referer", .value = "https://xonecas.io/mini-coding-agent/" }, 10 .{ .name = "X-OpenRouter-Title", .value = "mini-coding-agent" }, 11}; 12 13fn isOpenRouter(uri: std.Uri) bool { 14 const host = switch (uri.host orelse return false) { 15 inline else => |h| h, 16 }; 17 return std.mem.eql(u8, host, "openrouter.ai") or std.mem.endsWith(u8, host, ".openrouter.ai"); 18} 19 20pub const Header = struct { name: []const u8, value: []const u8 }; 21 22pub const SseHandler = struct { 23 ctx: *anyopaque, 24 onEvent: *const fn (ctx: *anyopaque, data: []const u8) void, 25 26 fn call(self: SseHandler, data: []const u8) void { 27 self.onEvent(self.ctx, data); 28 } 29}; 30 31const HttpError = error{ 32 RequestFailed, 33 HttpStatus, 34 ReadFailed, 35 IdleTimeout, 36 Aborted, 37} || std.mem.Allocator.Error; 38 39pub const Retry = struct { 40 attempts: usize = 3, 41 base_ms: u64 = 1000, 42 idle_ms: u64 = 120_000, 43}; 44 45const max_backoff_ms: u64 = 30_000; 46 47pub const RetryNotice = struct { 48 ctx: *anyopaque, 49 on_retry: *const fn (ctx: *anyopaque, attempt: usize, total: usize, delay_ms: u64, reason: []const u8) void, 50 51 fn call(self: RetryNotice, attempt: usize, total: usize, delay_ms: u64, reason: []const u8) void { 52 self.on_retry(self.ctx, attempt, total, delay_ms, reason); 53 } 54}; 55 56const Watch = struct { 57 cancel: *const std.atomic.Value(bool), 58 connection: *std.http.Client.Connection, 59 idle_ms: u64, 60 last: std.atomic.Value(i64), 61 idle: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), 62 done: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), 63 64 fn run(self: *Watch) void { 65 while (!self.done.load(.acquire)) { 66 if (self.cancel.load(.acquire)) { 67 self.hangUp(); 68 return; 69 } 70 if (self.idle_ms > 0 and time.nowMs() - self.last.load(.acquire) >= self.idle_ms) { 71 self.idle.store(true, .release); 72 self.hangUp(); 73 return; 74 } 75 std.Io.sleep(platform.io, .{ .nanoseconds = 25 * std.time.ns_per_ms }, .boot) catch {}; 76 } 77 } 78 79 fn hangUp(self: *Watch) void { 80 self.connection.stream_reader.stream.shutdown(platform.io, .both) catch {}; 81 } 82}; 83 84const Exchange = struct { 85 a: std.mem.Allocator, 86 client: std.http.Client, 87 hdrs: std.ArrayList(std.http.Header) = .empty, 88 req: std.http.Client.Request, 89 response: std.http.Client.Response, 90 status: u16 = 0, 91 transfer: [16 * 1024]u8 = undefined, 92 decompress: std.http.Decompress = undefined, 93 decompress_buf: [std.compress.flate.max_window_len]u8 = undefined, 94 reader: *std.Io.Reader = undefined, 95 96 fn open(self: *Exchange, a: std.mem.Allocator, method: std.http.Method, url: []const u8, headers: []const Header, body: ?[]const u8) HttpError!void { 97 self.a = a; 98 self.hdrs = .empty; 99 const uri = std.Uri.parse(url) catch return error.RequestFailed; 100 self.client = .{ .allocator = a, .io = platform.io }; 101 errdefer self.client.deinit(); 102 for (headers) |h| self.hdrs.append(a, .{ .name = h.name, .value = h.value }) catch return error.OutOfMemory; 103 if (isOpenRouter(uri)) { 104 for (openrouter_headers) |h| self.hdrs.append(a, h) catch return error.OutOfMemory; 105 } 106 errdefer self.hdrs.deinit(a); 107 self.req = self.client.request(method, uri, .{ 108 .redirect_behavior = .unhandled, 109 .extra_headers = self.hdrs.items, 110 .headers = .{ .user_agent = .{ .override = user_agent } }, 111 }) catch return error.RequestFailed; 112 errdefer self.req.deinit(); 113 if (body) |b| { 114 self.req.transfer_encoding = .{ .content_length = b.len }; 115 var bw = self.req.sendBodyUnflushed(&.{}) catch return error.RequestFailed; 116 bw.writer.writeAll(b) catch return error.RequestFailed; 117 bw.end() catch return error.RequestFailed; 118 self.req.connection.?.flush() catch return error.RequestFailed; 119 } else { 120 self.req.sendBodiless() catch return error.RequestFailed; 121 } 122 } 123 124 fn receive(self: *Exchange) HttpError!void { 125 self.response = self.req.receiveHead(&.{}) catch return error.RequestFailed; 126 self.status = @backingInt(self.response.head.status); 127 self.reader = self.response.readerDecompressing(&self.transfer, &self.decompress, &self.decompress_buf); 128 } 129 130 fn ok(self: *Exchange) bool { 131 return self.status >= 200 and self.status < 300; 132 } 133 134 fn close(self: *Exchange) void { 135 self.req.deinit(); 136 self.hdrs.deinit(self.a); 137 self.client.deinit(); 138 } 139}; 140 141const Attempt = struct { 142 status: u16 = 0, 143 sent: bool = false, 144 err: ?HttpError = null, 145}; 146 147pub fn get( 148 a: std.mem.Allocator, 149 url: []const u8, 150 headers: []const Header, 151 cancel: *const std.atomic.Value(bool), 152 retry: Retry, 153) HttpError![]u8 { 154 var attempt: usize = 0; 155 while (true) : (attempt += 1) { 156 var out = Attempt{}; 157 if (getOnce(a, url, headers, cancel, &out)) |body| { 158 return body; 159 } else |e| { 160 if (attempt >= retry.attempts or !retryable(e, out.status)) return e; 161 } 162 try pause(cancel, backoff(retry.base_ms, attempt)); 163 } 164} 165 166fn getOnce( 167 a: std.mem.Allocator, 168 url: []const u8, 169 headers: []const Header, 170 cancel: *const std.atomic.Value(bool), 171 out: *Attempt, 172) HttpError![]u8 { 173 if (cancel.load(.acquire)) return error.Aborted; 174 var ex: Exchange = undefined; 175 try ex.open(a, .GET, url, headers, null); 176 defer ex.close(); 177 try ex.receive(); 178 out.status = ex.status; 179 if (!ex.ok()) return error.HttpStatus; 180 return ex.reader.allocRemaining(a, .limited(1 << 22)) catch return error.ReadFailed; 181} 182 183pub fn postSse( 184 a: std.mem.Allocator, 185 url: []const u8, 186 headers: []const Header, 187 body: []const u8, 188 handler: SseHandler, 189 cancel: *const std.atomic.Value(bool), 190 err_body: *?[]const u8, 191 retry: Retry, 192 notice: ?RetryNotice, 193) HttpError!void { 194 var attempt: usize = 0; 195 while (true) : (attempt += 1) { 196 err_body.* = null; 197 const out = postOnce(a, url, headers, body, handler, cancel, err_body, retry.idle_ms); 198 const e = out.err orelse return; 199 if (out.sent or attempt >= retry.attempts or !retryable(e, out.status)) return e; 200 const delay_ms = backoff(retry.base_ms, attempt); 201 if (notice) |n| { 202 var buf: [16]u8 = undefined; 203 n.call(attempt + 2, retry.attempts + 1, delay_ms, describe(e, out.status, &buf)); 204 } 205 try pause(cancel, delay_ms); 206 } 207} 208 209fn postOnce( 210 a: std.mem.Allocator, 211 url: []const u8, 212 headers: []const Header, 213 body: []const u8, 214 handler: SseHandler, 215 cancel: *const std.atomic.Value(bool), 216 err_body: *?[]const u8, 217 idle_ms: u64, 218) Attempt { 219 var out = Attempt{}; 220 if (cancel.load(.acquire)) { 221 out.err = error.Aborted; 222 return out; 223 } 224 var ex: Exchange = undefined; 225 ex.open(a, .POST, url, headers, body) catch |e| { 226 out.err = e; 227 return out; 228 }; 229 defer ex.close(); 230 231 var watch = Watch{ .cancel = cancel, .connection = ex.req.connection.?, .idle_ms = idle_ms, .last = std.atomic.Value(i64).init(time.nowMs()) }; 232 const watcher = std.Thread.spawn(.{}, Watch.run, .{&watch}) catch null; 233 defer { 234 watch.done.store(true, .release); 235 if (watcher) |t| t.join(); 236 } 237 238 ex.receive() catch { 239 out.err = if (watch.idle.load(.acquire)) error.IdleTimeout else error.RequestFailed; 240 return out; 241 }; 242 out.status = ex.status; 243 if (!ex.ok()) { 244 err_body.* = ex.reader.allocRemaining(a, .limited(1 << 20)) catch null; 245 out.err = error.HttpStatus; 246 return out; 247 } 248 249 var data: std.ArrayList(u8) = .empty; 250 defer data.deinit(a); 251 var line: std.ArrayList(u8) = .empty; 252 defer line.deinit(a); 253 var have_data = false; 254 var buf: [4096]u8 = undefined; 255 256 while (true) { 257 if (cancel.load(.acquire)) { 258 out.err = error.Aborted; 259 return out; 260 } 261 const n = ex.reader.readSliceShort(&buf) catch { 262 out.err = if (watch.idle.load(.acquire)) error.IdleTimeout else error.ReadFailed; 263 return out; 264 }; 265 if (n == 0) break; 266 watch.last.store(time.nowMs(), .release); 267 var rest: []const u8 = buf[0..n]; 268 while (std.mem.indexOfScalar(u8, rest, '\n')) |nl| { 269 line.appendSlice(a, rest[0..nl]) catch { 270 out.err = error.OutOfMemory; 271 return out; 272 }; 273 rest = rest[nl + 1 ..]; 274 const complete = feedLine(a, line.items, &data, &have_data) catch { 275 out.err = error.OutOfMemory; 276 return out; 277 }; 278 if (complete) { 279 out.sent = true; 280 handler.call(data.items); 281 data.clearRetainingCapacity(); 282 have_data = false; 283 } 284 line.clearRetainingCapacity(); 285 } 286 line.appendSlice(a, rest) catch { 287 out.err = error.OutOfMemory; 288 return out; 289 }; 290 } 291 if (watch.idle.load(.acquire)) { 292 out.err = error.IdleTimeout; 293 return out; 294 } 295 if (line.items.len > 0) { 296 const complete = feedLine(a, line.items, &data, &have_data) catch { 297 out.err = error.OutOfMemory; 298 return out; 299 }; 300 if (complete) { 301 out.sent = true; 302 handler.call(data.items); 303 data.clearRetainingCapacity(); 304 have_data = false; 305 } 306 } 307 if (have_data) { 308 out.sent = true; 309 handler.call(data.items); 310 } 311 return out; 312} 313 314fn retryable(e: HttpError, status: u16) bool { 315 return switch (e) { 316 error.RequestFailed, error.ReadFailed, error.IdleTimeout => true, 317 error.HttpStatus => status == 429 or status >= 500, 318 error.Aborted, error.OutOfMemory => false, 319 }; 320} 321 322fn backoff(base_ms: u64, attempt: usize) u64 { 323 const shift: u6 = @intCast(@min(attempt, 6)); 324 return @min(base_ms << shift, max_backoff_ms); 325} 326 327fn describe(e: HttpError, status: u16, buf: []u8) []const u8 { 328 return switch (e) { 329 error.HttpStatus => std.fmt.bufPrint(buf, "http {d}", .{status}) catch "http error", 330 error.IdleTimeout => "idle timeout", 331 error.ReadFailed => "stream interrupted", 332 else => "connection failed", 333 }; 334} 335 336fn pause(cancel: *const std.atomic.Value(bool), delay_ms: u64) HttpError!void { 337 var left = delay_ms; 338 while (left > 0) { 339 if (cancel.load(.acquire)) return error.Aborted; 340 const step: u64 = @min(left, 25); 341 std.Io.sleep(platform.io, .{ .nanoseconds = step * std.time.ns_per_ms }, .boot) catch {}; 342 left -= step; 343 } 344 if (cancel.load(.acquire)) return error.Aborted; 345} 346 347fn feedLine( 348 a: std.mem.Allocator, 349 raw: []const u8, 350 data: *std.ArrayList(u8), 351 have_data: *bool, 352) std.mem.Allocator.Error!bool { 353 var line = raw; 354 if (line.len > 0 and line[line.len - 1] == '\r') line = line[0 .. line.len - 1]; 355 356 if (line.len == 0) return have_data.*; 357 if (line[0] == ':') return false; 358 if (std.mem.startsWith(u8, line, "data:")) { 359 var value = line[5..]; 360 if (value.len > 0 and value[0] == ' ') value = value[1..]; 361 if (have_data.*) try data.append(a, '\n'); 362 try data.appendSlice(a, value); 363 have_data.* = true; 364 } 365 return false; 366}