From 45dd56258b7342efff9a70acd2cb4c2608ab94e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adri=C3=A0=20Arrufat?= Date: Wed, 17 Jun 2026 12:45:12 +0200 Subject: [PATCH] agent: simplify and shorten comments --- src/agent/Agent.zig | 22 +++++++--------------- src/agent/settings.zig | 11 ++++------- 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/src/agent/Agent.zig b/src/agent/Agent.zig index a528fe0d0..6924f536a 100644 --- a/src/agent/Agent.zig +++ b/src/agent/Agent.zig @@ -259,9 +259,8 @@ total_usage: zenai.provider.Usage = .{}, /// Set when the last turn ended in a model refusal (safety stop). last_turn_refused: bool = false, available_providers: []const []const u8, -/// Lazily-probed reachability of each `local_providers` entry for `/provider` -/// completion, cached so the per-keystroke hinter probes each local server at -/// most once per session. +/// Cached reachability of each `local_providers` entry, so the per-keystroke +/// `/provider` hinter probes each local server at most once. local_completable: [local_providers.len]?bool = @splat(null), api_error_buf: [512]u8 = undefined, /// Last failure's status+message, surfaced by `runTurn` past `error.ApiError`. @@ -589,8 +588,6 @@ fn runTurn(self: *Agent, input: TurnInput) bool { return false; }, else => { - // Detail is set by `processUserMessage`'s catch and cleared at the - // start of the next turn; fall back to the raw error name. self.terminal.printError("{s} failed: {s}", .{ input.label, self.api_error_detail orelse @errorName(err) }); return false; }, @@ -817,9 +814,8 @@ const llm_setup_hint = "set an API key (" ++ api_keys_hint ++ ") and run /provid /// parser, autocomplete, and save report so they can't drift apart. const provider_off_keyword = "null"; -/// Keyless local providers whose env key is a placeholder, so reachability needs -/// a live `/v1/models` probe (`settings.detectLocalProvider`). Indexes into -/// `local_completable`. +/// Keyless local providers (placeholder key), so reachability needs a live probe. +/// Parallel to `local_completable`. const local_providers = [_]Config.AiProvider{ .ollama, .llama_cpp }; fn requireLlm(self: *Agent, name: []const u8) bool { @@ -909,7 +905,6 @@ fn handleProvider(self: *Agent, _: std.mem.Allocator, rest: []const u8) void { self.terminal.printError("no Ollama server with a pulled model at {s}", .{self.model_base_url orelse zenai.provider.ollama_default_base_url}); return; } - // llama.cpp's key is also a placeholder — probe its server too. if (provider == .llama_cpp and settings.detectLlamaCpp(self.allocator, self.model_base_url) == null) { self.terminal.printError("no llama.cpp server with a loaded model at {s}", .{self.model_base_url orelse zenai.provider.llama_cpp_default_base_url}); return; @@ -1475,10 +1470,8 @@ fn recordSlashToolCall( }); } -/// Render the client's last failure into `api_error_buf`. Prefers the server's -/// HTTP status+message; with no status (transport/parse/empty-response failures) -/// falls back to the concrete error name, which the caller would otherwise lose -/// to the blanket `error.ApiError`. Status-only when the message overflows. +/// Format the client's last failure into `api_error_buf`: HTTP status+message, +/// or the raw error name when there's no status (transport/parse failures). fn formatApiError(self: *Agent, client: zenai.provider.Client, err: anyerror) []const u8 { const e = client.lastError(); const status = e.status orelse return @errorName(err); @@ -1772,8 +1765,7 @@ const ModelCompletions = struct { /// avoid reading environment variables on each autocomplete keypress. fn completionProviders(context: *anyopaque, arena: std.mem.Allocator) []const []const u8 { const self: *Agent = @ptrCast(@alignCast(context)); - // A local server joins `/provider` completions only when it actually answers, - // since its env key is a placeholder. Probe each once and cache the result. + // A local server joins completions only when it answers (placeholder key). var reachable: [local_providers.len]bool = undefined; var extra: usize = 0; for (local_providers, 0..) |tag, i| { diff --git a/src/agent/settings.zig b/src/agent/settings.zig index 24041a21a..1aadd8008 100644 --- a/src/agent/settings.zig +++ b/src/agent/settings.zig @@ -40,8 +40,7 @@ pub const ResolvedProvider = struct { source: enum { flag, remembered, detected, picked }, }; -/// Probe a keyless local provider (Ollama, llama.cpp). These are excluded from -/// env detection (`default_candidates`) because their env key is a constant +/// Probe a keyless local provider (Ollama, llama.cpp): its env key is a /// placeholder, so the only honest availability signal is the server answering /// `/v1/models` with a loaded model. Null means no server responded. pub fn detectLocalProvider(allocator: std.mem.Allocator, tag: Config.AiProvider, base_url: ?[:0]const u8) ?Credentials { @@ -202,11 +201,9 @@ pub const ReconciledModel = union(enum) { /// Validate `desired` against the provider's catalog, mirroring the interactive /// `/model` command. Empty list (unreachable server) leaves it unchecked; an -/// explicit unlisted model is fatal. The local servers' catalogs (Ollama, -/// llama.cpp) are authoritative, so their default is substituted with the first -/// served model when it isn't loaded — llama.cpp's default is empty, since the -/// served model is whatever `llama-server` was launched with; cloud defaults are -/// hardcoded real models, trusted as-is. +/// explicit unlisted model is fatal. The local servers (Ollama, llama.cpp) have +/// authoritative catalogs, so their default is substituted with the first served +/// model when unloaded; cloud defaults are hardcoded real models, trusted as-is. pub fn reconcileModel( allocator: std.mem.Allocator, llm: Credentials,