Lightpanda: the headless browser designed for AI and automation
search: make SearchEngine declaration order the .auto preference order
Adrià Arrufat12ecf27fb173
diff --git a/src/browser/tools.zig b/src/browser/tools.zigindex 03a5b44cf..5154c8fa7 100644--- a/src/browser/tools.zig+++ b/src/browser/tools.zig@@ -979,19 +979,23 @@ pub const SearchParams = struct {timeout: ?u32 = null,};-/// Search backend for `execSearch`. `.auto` tries the `api_engines` in-/// order (each only when its API key is set), then Keenable's keyless-/// public endpoint, then the DuckDuckGo scrape; an explicit engine is-/// used alone. Only the agent REPL's `/searchEngine` mutates this.-pub const SearchEngine = enum { auto, tavily, brave, exa, keenable, duckduckgo };+/// Search backend for `execSearch`. `.auto` tries the API engines in+/// declaration order (each only when its API key is set), then the keyless+/// public endpoint of `.keyless` engines (keenable), then the DuckDuckGo+/// scrape; an explicit engine is used alone. Declaration order after `auto`+/// is the `.auto` preference order (asserted against `api_engines` below);+/// `duckduckgo` (the scrape fallback, no table entry) is last. Only the+/// agent REPL's `/searchEngine` mutates this.+pub const SearchEngine = enum { auto, brave, tavily, exa, keenable, duckduckgo };pub var search_engine: SearchEngine = .auto;-// Ordered by `.auto` preference; the `search` tool description prose must-// agree with this table.+// One entry per API engine, in `SearchEngine` declaration order (asserted+// below); the `search` tool description prose must agree with this table.const api_engines = .{.{.tag = SearchEngine.brave,.env_var = "BRAVE_API_KEY",+ .keyless = false,.Client = brave.Client,.init_options = brave.Client.InitOptions{},// text_decorations=false: no <strong> markup in model-read snippets.@@ -1001,6 +1005,7 @@ const api_engines = .{.{.tag = SearchEngine.tavily,.env_var = "TAVILY_API_KEY",+ .keyless = false,.Client = tavily.Client,.init_options = tavily.Client.InitOptions{},.options = tavily.types.SearchOptions{ .max_results = 10 },@@ -1009,6 +1014,7 @@ const api_engines = .{.{.tag = SearchEngine.exa,.env_var = "EXA_API_KEY",+ .keyless = false,.Client = exa.Client,.init_options = exa.Client.InitOptions{},// highlights: Exa returns no snippet text unless contents is requested;@@ -1019,6 +1025,9 @@ const api_engines = .{.{.tag = SearchEngine.keenable,.env_var = "KEENABLE_API_KEY",+ // Also works with no API key: a `null` key routes the client to the+ // keyless public endpoint (rate-limited per client IP).+ .keyless = true,.Client = keenable.Client,// Retries off: the fallback cascade is the retry mechanism, and// honoring the public endpoint's Retry-After (60s per sleep) would@@ -1031,11 +1040,27 @@ const api_engines = .{},};+// `SearchEngine` declaration order is the single source of truth: tags must+// appear in `api_engines` in declaration order, with `auto` first and+// `duckduckgo` (scrape fallback, no table entry) last.+comptime {+ std.debug.assert(@intFromEnum(SearchEngine.auto) == 0);+ std.debug.assert(api_engines.len == std.enums.values(SearchEngine).len - 2);+ std.debug.assert(@intFromEnum(SearchEngine.duckduckgo) == api_engines.len + 1);+ for (api_engines, 0..) |e, i| {+ if (@intFromEnum(e.tag) != i + 1)+ @compileError("api_engines order must match SearchEngine declaration order: " ++ @tagName(e.tag));+ }+}+/// Engines that also work with no API key (a `null` key routes the client/// to the provider's public endpoint). `searchExplicit` and the REPL's/// `/searchEngine` warning consult this.pub fn searchEngineKeyless(engine: SearchEngine) bool {- return engine == .keenable;+ inline for (api_engines) |e| {+ if (engine == e.tag) return e.keyless;+ }+ return false;}pub fn searchEnvVar(engine: SearchEngine) ?[:0]const u8 {@@ -1045,11 +1070,9 @@ pub fn searchEnvVar(engine: SearchEngine) ?[:0]const u8 {return null;}+/// Valid for any API engine tag; the comptime block above pins tag order.fn engineIndex(comptime tag: SearchEngine) usize {- inline for (api_engines, 0..) |e, i| {- if (e.tag == tag) return i;- }- @compileError("engine missing from api_engines: " ++ @tagName(tag));+ return @intFromEnum(tag) - 1;}fn execSearch(arena: std.mem.Allocator, session: *lp.Session, registry: *CDPNode.Registry, arguments: ?std.json.Value) ToolError!ToolResult {@@ -1069,14 +1092,17 @@ fn execSearch(arena: std.mem.Allocator, session: *lp.Session, registry: *CDPNode}}}- // One rung above the DDG scrape: the keyless public endpoint- // returns the same structured results under its own rate-limit- // regime — worth trying even after a failed keyed attempt.- const kn = api_engines[comptime engineIndex(.keenable)];- if (apiSearch(kn, arena, null, args.query)) |markdown_| {- return .{ .text = markdown_ };- } else |err| {- log.warn(.browser, "keenable keyless fallback", .{ .err = err });+ // One rung above the DDG scrape: keyless public endpoints return+ // the same structured results under their own rate-limit regime+ // — worth trying even after a failed keyed attempt.+ inline for (api_engines) |engine| {+ if (comptime engine.keyless) {+ if (apiSearch(engine, arena, null, args.query)) |markdown_| {+ return .{ .text = markdown_ };+ } else |err| {+ log.warn(.browser, @tagName(engine.tag) ++ " keyless fallback", .{ .err = err });+ }+ }}},.duckduckgo => {},@@ -1105,7 +1131,7 @@ fn searchExplicit(arena: std.mem.Allocator, comptime engine: anytype, query: []cbreak :blk apiSearch(engine, arena, std.mem.span(z), query);// Comptime-gated so the null-key call is only instantiated for// clients whose `init` takes an optional key.- if (comptime searchEngineKeyless(engine.tag))+ if (comptime engine.keyless)break :blk apiSearch(engine, arena, null, query);return .{.text = "web search engine is set to " ++ label ++ " but " ++ engine.env_var ++ " is not set in the environment",@@ -1120,15 +1146,20 @@ fn searchExplicit(arena: std.mem.Allocator, comptime engine: anytype, query: []c}/// `arena` owns the returned slice. `api_key` is the environment value, or-/// `null` for an engine that supports keyless calls (its client's `init`-/// takes a `?[]const u8` key — see `searchEngineKeyless`).+/// `null` for a `.keyless` engine's public endpoint (its client's `init`+/// takes a `?[]const u8` key; keyed clients get the unwrapped slice).fn apiSearch(comptime engine: anytype,arena: std.mem.Allocator,- api_key: anytype,+ api_key: ?[]const u8,query: []const u8,) ![]const u8 {- var client: engine.Client = .init(lp.io, arena, api_key, engine.init_options);+ var client: engine.Client = .init(+ lp.io,+ arena,+ if (comptime engine.keyless) api_key else api_key.?,+ engine.init_options,+ );defer client.deinit();var response = client.search(query, engine.options) catch |err| {