xonecas.io
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}