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}