xonecas.io
79113
Ma

mini-coding-agent / files

mini-coding-agent / src / agent.zig

11.9 KB
1const std = @import("std");
2const message_mod = @import("message.zig");
3const models = @import("models.zig");
4const api = @import("api.zig");
5const platform = @import("platform.zig");
6const tools = @import("tools.zig");
7const session = @import("session.zig");
8const config = @import("config.zig");
9const time = @import("time.zig");
10const text = @import("text.zig");
11
12pub const Phase = enum { preparing, waiting_model, streaming, running_tool, snapshotting, pausing, idle };
13
14pub const Event = union(enum) {
15    phase: struct { phase: Phase, detail: ?[]const u8 = null },
16    retry: struct { attempt: u32, total: u32, delay_ms: u64, reason: []const u8 },
17    text: []const u8,
18    reasoning: []const u8,
19    tool_call_start: []const u8,
20    tool_args: usize,
21    tool_call: struct { name: []const u8, arguments: []const u8 },
22    tool_output: []const u8,
23    tool_result: struct { name: []const u8, text: []const u8, is_error: bool, diffs: []const tools.FileDiff, body: ?[]const u8, images: []const message_mod.ImageContent },
24    message: *message_mod.AssistantMessage,
25    no_model,
26    err: []const u8,
27    cancelled,
28    complete,
29};
30
31pub const Listener = struct {
32    ctx: *anyopaque,
33    on_event: *const fn (ctx: *anyopaque, event: Event) void,
34
35    pub fn emit(self: Listener, event: Event) void {
36        self.on_event(self.ctx, event);
37    }
38};
39
40pub const Interaction = struct {
41    ctx: *anyopaque,
42    is_pause_requested: *const fn (ctx: *anyopaque) bool,
43    clear_pause: *const fn (ctx: *anyopaque) void,
44    request_steering: *const fn (ctx: *anyopaque) []const u8,
45
46    pub fn pauseRequested(self: Interaction) bool {
47        return self.is_pause_requested(self.ctx);
48    }
49    pub fn clearPause(self: Interaction) void {
50        self.clear_pause(self.ctx);
51    }
52    pub fn requestSteering(self: Interaction) []const u8 {
53        return self.request_steering(self.ctx);
54    }
55};
56
57pub const Options = struct {
58    a: std.mem.Allocator,
59    model: ?*const models.Model,
60    system_prompt: []const u8,
61    loaded: struct { agent_files: usize = 0, skills: usize = 0 } = .{},
62    tools_json: []const u8,
63    supports_images: bool,
64    session: *session.Session,
65    cancel: *const std.atomic.Value(bool),
66    config: *const config.Config,
67    messages_mutex: ?*std.Io.Mutex = null,
68};
69
70fn lockMessages(opts: Options) void {
71    if (opts.messages_mutex) |m| m.lockUncancelable(platform.io);
72}
73
74fn unlockMessages(opts: Options) void {
75    if (opts.messages_mutex) |m| m.unlock(platform.io);
76}
77
78const StreamCtx = struct { listener: Listener, started: bool = false };
79
80const ToolPhaseCtx = struct { listener: Listener, name: []const u8 };
81
82fn onToolPhase(ctx: *anyopaque, phase: tools.ToolPhase) void {
83    const c: *ToolPhaseCtx = @ptrCast(@alignCast(ctx));
84    switch (phase) {
85        .snapshotting => c.listener.emit(.{ .phase = .{ .phase = .snapshotting } }),
86        .running => c.listener.emit(.{ .phase = .{ .phase = .running_tool, .detail = c.name } }),
87    }
88}
89
90fn onApiEvent(ctx: *anyopaque, event: api.Event) void {
91    const stream_ctx: *StreamCtx = @ptrCast(@alignCast(ctx));
92    const listener = stream_ctx.listener;
93    if (std.meta.activeTag(event) == .retry) {
94        const r = event.retry;
95        listener.emit(.{ .retry = .{
96            .attempt = r.attempt,
97            .total = r.total,
98            .delay_ms = r.delay_ms,
99            .reason = r.reason,
100        } });
101        return;
102    }
103    if (!stream_ctx.started) {
104        stream_ctx.started = true;
105        listener.emit(.{ .phase = .{ .phase = .streaming } });
106    }
107    switch (event) {
108        .retry => unreachable,
109        .text => |d| listener.emit(.{ .text = d }),
110        .reasoning => |d| listener.emit(.{ .reasoning = d }),
111        .tool_start => |name| listener.emit(.{ .tool_call_start = name }),
112        .tool_args => |n| listener.emit(.{ .tool_args = n }),
113        .tool_call => |call| listener.emit(.{ .tool_call = .{ .name = call.name, .arguments = call.arguments } }),
114    }
115}
116
117fn onToolOutput(ctx: *anyopaque, chunk: []const u8) void {
118    const listener: *Listener = @ptrCast(@alignCast(ctx));
119    listener.emit(.{ .tool_output = chunk });
120}
121
122fn pushMessage(opts: Options, messages: *std.ArrayList(message_mod.Message), message: message_mod.Message) !void {
123    lockMessages(opts);
124    defer unlockMessages(opts);
125    try messages.append(opts.a, message);
126}
127
128fn steer(opts: Options, messages: *std.ArrayList(message_mod.Message), content: []const u8) !void {
129    if (content.len == 0) return;
130    const owned = try opts.a.dupe(u8, content);
131    const message = message_mod.Message{ .user = .{ .content = owned, .timestamp = time.nowMs() } };
132    try pushMessage(opts, messages, message);
133    try opts.session.appendMessage(opts.a, message);
134}
135
136fn pauseStep(run: Run) ?[]const u8 {
137    const interaction = run.interaction orelse return "";
138    if (!interaction.pauseRequested()) return "";
139    interaction.clearPause();
140    run.listener.emit(.{ .phase = .{ .phase = .pausing } });
141    const steering = interaction.requestSteering();
142    run.listener.emit(.{ .phase = .{ .phase = .idle } });
143    if (run.opts.cancel.load(.acquire)) return null;
144    return steering;
145}
146
147fn cancelled(opts: Options, listener: Listener) bool {
148    if (!opts.cancel.load(.acquire)) return false;
149    listener.emit(.cancelled);
150    return true;
151}
152
153const Run = struct {
154    opts: Options,
155    messages: *std.ArrayList(message_mod.Message),
156    interaction: ?Interaction,
157    listener: Listener,
158};
159
160pub fn runTurn(opts: Options, messages: *std.ArrayList(message_mod.Message), interaction: ?Interaction, listener: Listener) void {
161    const run = Run{ .opts = opts, .messages = messages, .interaction = interaction, .listener = listener };
162
163    const model = opts.model orelse {
164        listener.emit(.no_model);
165        return;
166    };
167
168    var arena = std.heap.ArenaAllocator.init(opts.a);
169    defer arena.deinit();
170
171    while (true) {
172        _ = arena.reset(.retain_capacity);
173        const scratch = arena.allocator();
174
175        if (cancelled(opts, listener)) return;
176        const steering = pauseStep(run) orelse {
177            listener.emit(.cancelled);
178            return;
179        };
180        steer(opts, messages, steering) catch |e| {
181            listener.emit(.{ .err = @errorName(e) });
182            return;
183        };
184
185        if (cancelled(opts, listener)) return;
186        listener.emit(.{ .phase = .{ .phase = .preparing } });
187        opts.session.appendRequest(scratch, .{
188            .provider = model.provider,
189            .model = model.id,
190            .api = model.api,
191            .thinking_effort = model.effort,
192            .system_prompt = opts.system_prompt,
193            .tools_json = opts.tools_json,
194        }) catch |e| {
195            listener.emit(.{ .err = @errorName(e) });
196            return;
197        };
198
199        if (cancelled(opts, listener)) return;
200        listener.emit(.{ .phase = .{ .phase = .waiting_model } });
201        var stream_ctx = StreamCtx{ .listener = listener };
202        const assistant = opts.a.create(message_mod.AssistantMessage) catch {
203            listener.emit(.{ .err = "out of memory" });
204            return;
205        };
206        assistant.* = api.stream(.{
207            .pers = opts.a,
208            .scratch = scratch,
209            .model = model,
210            .system_prompt = opts.system_prompt,
211            .tools_json = opts.tools_json,
212            .messages = messages.items,
213            .effort = model.effort,
214            .session_id = opts.session.id,
215            .cancel = opts.cancel,
216            .retry = .{
217                .attempts = opts.config.retries,
218                .base_ms = opts.config.retry_base_ms,
219                .idle_ms = opts.config.stream_idle_timeout_ms,
220            },
221        }, .{ .ctx = &stream_ctx, .on_event = onApiEvent }) catch |e| {
222            listener.emit(.{ .err = @errorName(e) });
223            return;
224        };
225
226        if (assistant.stop_reason == .err) {
227            listener.emit(.{ .err = assistant.error_message orelse "provider error" });
228            return;
229        }
230
231        pushMessage(opts, messages, .{ .assistant = assistant }) catch {
232            listener.emit(.{ .err = "out of memory" });
233            return;
234        };
235        opts.session.appendMessage(scratch, .{ .assistant = assistant }) catch |e| {
236            listener.emit(.{ .err = @errorName(e) });
237            return;
238        };
239        listener.emit(.{ .message = assistant });
240
241        if (assistant.stop_reason == .aborted) {
242            listener.emit(.cancelled);
243            return;
244        }
245
246        const has_calls = for (assistant.content.items) |block| {
247            if (block == .tool_call) break true;
248        } else false;
249        if (!has_calls) {
250            listener.emit(.complete);
251            return;
252        }
253
254        var held: std.ArrayList([]const u8) = .empty;
255        defer held.deinit(opts.a);
256        var run_tools = true;
257        for (assistant.content.items) |block| {
258            if (block != .tool_call) continue;
259            const call = block.tool_call;
260
261            if (run_tools) {
262                if (opts.cancel.load(.acquire)) {
263                    run_tools = false;
264                } else if (pauseStep(run)) |step| {
265                    if (step.len > 0) held.append(opts.a, step) catch {
266                        listener.emit(.{ .err = "out of memory" });
267                        return;
268                    };
269                } else {
270                    run_tools = false;
271                }
272            }
273            if (run_tools and opts.cancel.load(.acquire)) run_tools = false;
274
275            var result: ?tools.Result = null;
276            if (run_tools) {
277                listener.emit(.{ .phase = .{ .phase = .running_tool, .detail = call.name } });
278                var phase_ctx = ToolPhaseCtx{ .listener = listener, .name = call.name };
279                result = tools.execute(opts.a, scratch, call.name, call.arguments, .{
280                    .cancel = opts.cancel,
281                    .supports_images = opts.supports_images,
282                    .tools = opts.config.tools,
283                    .on_output = .{ .ctx = &stream_ctx.listener, .on_chunk = onToolOutput },
284                    .on_phase = .{ .ctx = &phase_ctx, .on_phase = onToolPhase },
285                    .snapshot_ignore_dirs = opts.config.snapshot_ignore_dirs,
286                    .snapshot_uses_gitignore = opts.config.snapshot_uses_gitignore,
287                    .snapshot_diffs_in_context = opts.config.snapshot_diffs_in_context,
288                });
289            }
290
291            const tool_message = message_mod.Message{ .tool_result = .{
292                .tool_call_id = call.id,
293                .tool_name = call.name,
294                .text = if (result) |r| r.model_text orelse r.text else "aborted",
295                .images = if (result) |r| r.images else &.{},
296                .is_error = if (result) |r| r.is_error else true,
297                .timestamp = time.nowMs(),
298            } };
299            pushMessage(opts, messages, tool_message) catch {
300                listener.emit(.{ .err = "out of memory" });
301                return;
302            };
303            opts.session.appendMessage(scratch, tool_message) catch |e| {
304                listener.emit(.{ .err = @errorName(e) });
305                return;
306            };
307            listener.emit(.{ .tool_result = .{
308                .name = call.name,
309                .text = if (result) |r| r.text else "aborted",
310                .is_error = tool_message.tool_result.is_error,
311                .diffs = if (result) |r| r.diffs else &.{},
312                .body = if (result) |r| r.body else null,
313                .images = if (result) |r| r.images else &.{},
314            } });
315        }
316        if (!run_tools) {
317            listener.emit(.cancelled);
318            return;
319        }
320        if (cancelled(opts, listener)) return;
321        const joined = text.join(opts.a, held.items, "\n") catch {
322            listener.emit(.{ .err = "out of memory" });
323            return;
324        };
325        steer(opts, messages, joined) catch |e| {
326            listener.emit(.{ .err = @errorName(e) });
327            return;
328        };
329    }
330}