Skip to content

Lightpanda: the headless browser designed for AI and automation

tools: tell the caller why a search failed

Adrià Arrufat1c9b1b8bc203
diff --git a/src/browser/tools.zig b/src/browser/tools.zig
index 68b53c43f..5b597dfdc 100644
--- a/src/browser/tools.zig
+++ b/src/browser/tools.zig
@@ -1187,19 +1187,26 @@ fn execSearch(arena: std.mem.Allocator, arguments: ?std.json.Value) ToolError!To
switch (search_engine) {
.auto => {
var last_err: ?anyerror = null;
+ var last_label: []const u8 = "web";
+ var last_detail: Failure = .{};
inline for (api_engines) |engine| {
if (engineKey(engine)) |api_key| {
// Fall through on any failure so one outage doesn't kill
// a whole benchmark run.
- if (apiSearch(engine, arena, api_key, timeout_ms, args.query)) |markdown_| {
+ var detail: Failure = .{};
+ if (apiSearch(engine, arena, api_key, timeout_ms, args.query, &detail)) |markdown_| {
return .{ .text = markdown_ };
} else |err| {
last_err = err;
+ last_label = @tagName(engine.tag);
+ last_detail = detail;
log.warn(.browser, @tagName(engine.tag) ++ " fallback", .{ .err = err });
}
} else |_| {}
}
- return searchFailed(arena, "web", last_err.?);
+ // The last rung's reason, not a generic one: every engine having
+ // failed is usually one cause, and the model can act on it.
+ return searchFailed(arena, last_label, last_err.?, last_detail);
},
inline else => |tag| {
inline for (api_engines) |engine| {
@@ -1217,25 +1224,47 @@ fn searchExplicit(arena: std.mem.Allocator, comptime engine: anytype, timeout_ms
.text = "web search engine is set to " ++ label ++ " but " ++ engine.env_var ++ " is not set in the environment",
.is_error = true,
};
- const markdown_ = apiSearch(engine, arena, api_key, timeout_ms, query) catch |err|
- return searchFailed(arena, label, err);
+ var detail: Failure = .{};
+ const markdown_ = apiSearch(engine, arena, api_key, timeout_ms, query, &detail) catch |err|
+ return searchFailed(arena, label, err, detail);
return .{ .text = markdown_ };
}
-fn searchFailed(arena: std.mem.Allocator, comptime label: []const u8, err: anyerror) ToolError!ToolResult {
- return .{
- .text = try std.fmt.allocPrint(arena, label ++ " search failed: {s}", .{@errorName(err)}),
- .is_error = true,
- };
+/// What the provider said, duped out of the client before `deinit` takes it.
+/// Without this the status and body survive only in a log line, and every
+/// failure reaches the model as the word `InternalError`.
+const Failure = struct {
+ status: ?u10 = null,
+ message: []const u8 = "",
+};
+
+/// A rate limit and a bad key need different reactions, so the model is told
+/// which it hit rather than just that the search failed.
+fn searchFailed(arena: std.mem.Allocator, label: []const u8, err: anyerror, detail: Failure) ToolError!ToolResult {
+ var aw: std.Io.Writer.Allocating = .init(arena);
+ const w = &aw.writer;
+ w.print("{s} search failed: {s}", .{ label, @errorName(err) }) catch return ToolError.OutOfMemory;
+ if (detail.status) |status| w.print(" (HTTP {d})", .{status}) catch return ToolError.OutOfMemory;
+ if (detail.message.len > 0) {
+ w.writeAll(": ") catch return ToolError.OutOfMemory;
+ writeSingleLine(w, detail.message) catch return ToolError.OutOfMemory;
+ }
+ if (detail.status == 429) {
+ w.writeAll(". This engine is rate-limited right now; wait before retrying, or read the answer from a page instead.") catch
+ return ToolError.OutOfMemory;
+ }
+ return .{ .text = aw.written(), .is_error = true };
}
-/// `arena` owns the returned slice.
+/// `arena` owns the returned slice. `detail` is filled on a non-2xx so the
+/// caller can say what actually happened.
fn apiSearch(
comptime engine: anytype,
arena: std.mem.Allocator,
api_key: ?[]const u8,
timeout_ms: u32,
query: []const u8,
+ detail: *Failure,
) ![]const u8 {
var init_options = engine.init_options;
// The cascade (or the model) is the retry; honoring a Retry-After (60 s
@@ -1256,6 +1285,11 @@ fn apiSearch(
.status = status,
.body = client.last_error.body,
});
+ // `client.last_error` dies with the client on the deferred deinit.
+ detail.* = .{
+ .status = status,
+ .message = if (client.last_error.body) |b| (arena.dupe(u8, b) catch "") else "",
+ };
}
return err;
};
@@ -2909,6 +2943,29 @@ test "collectBrave flattens newlines in titles and descriptions" {
);
}
+test "searchFailed: a rate limit says so, a bare failure stays short" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const aa = arena.allocator();
+
+ const limited = try searchFailed(aa, "keenable", error.ApiError, .{
+ .status = 429,
+ .message = "Public API hourly limit reached.\nWait 2 minutes to continue.",
+ });
+ try std.testing.expect(limited.is_error);
+ // The status and the provider's own words, which previously reached the
+ // model only as the word "ApiError".
+ try std.testing.expect(std.mem.indexOf(u8, limited.text, "(HTTP 429)") != null);
+ try std.testing.expect(std.mem.indexOf(u8, limited.text, "Public API hourly limit reached.") != null);
+ try std.testing.expect(std.mem.indexOf(u8, limited.text, "rate-limited right now") != null);
+ // Flattened: a newline would break the numbered-list markdown around it.
+ try std.testing.expect(std.mem.indexOf(u8, limited.text, "\n") == null);
+
+ const bare = try searchFailed(aa, "web", error.ConnectionRefused, .{});
+ try std.testing.expectEqualStrings("web search failed: ConnectionRefused", bare.text);
+ try std.testing.expect(bare.is_error);
+}
+
test "isPathSafe: relative paths without traversal are accepted" {
try std.testing.expect(isPathSafe("foo.txt"));
try std.testing.expect(isPathSafe("./foo.txt"));