`, then falls back to headings, metadata, and body text.
-The same checks run before each page fetch and after every redirect. Administrator rules cannot override these blocks.
+Normal tool results never include raw HTML. Structured results contain:
-## Tool behavior
+- Status, query, reason, provider, policy mode, cache state, timing, counts, warnings, and errors
+- Normalized title, permitted URL, domain, snippet, date, rank, source, source ID, relevance score, and policy state
+- Fetched page URL, final URL, title, description, bounded readable text, content type, fetch time, and extraction state
-The registered tool ID is `lumi_ai_web_search.search`. It accepts:
+Lumi AI passes this structured result back to the model to produce the final natural answer. Normal users do not see raw tool JSON.
-- `query`
-- `reason`: `fact_lookup`, `resource_lookup`, `troubleshooting`, `documentation_lookup`, `news_or_recent`, or `general_lookup`
-- Optional `requested_depth`: `search` or `full_page`
-- Optional `freshness`
+## Settings
-The assistant should use this tool only for current or external information that is not available in verified local Lumi context.
+Open **Plugins -> Lumi AI -> Tools -> Lumi AI Web Search -> Settings**.
-The tool registers as a read-only lookup. This allows permitted Discord, Twitch, YouTube, Kick, and other contexts to use it even though those contexts cannot run WebUI action tools. Lumi AI evaluates the configured origin allowlist before including the tool in the model prompt and again before execution.
+The tool-owned settings panel shows:
-Results are sanitized and returned as structured data rather than raw provider JSON. Each result contains a title, permitted URL or no URL when links are disabled, domain, condensed snippet, source type, date, and relevance score. Documentation and troubleshooting searches prioritize authoritative sources; recent searches prioritize dated sources.
+- Provider and provider health
+- Search/fetch/summarize capability states
+- Policy mode and allowed origins
+- Last successful request and last error
+- Cache count and size
+- Recent redacted calls
+- A test field that uses Lumi Assistant's normal tool pipeline
-Optional full-page mode extracts bounded visible text only when the administrator enables it. It does not automate a browser, submit forms, execute scripts, or follow unrestricted links.
+Settings include capability toggles, URL policy, timeouts, byte/text limits, redirects, cache TTL, safe-search level, origins, source-link controls, per-origin output budgets, three rate-limit scopes, and optional external provider fields. **Reset to defaults** restores the no-key broker configuration.
-## Origin limits and rate limits
+## Output limits
-Allowed origins and output budgets are independently configurable for WebUI, Discord, Twitch, YouTube, Kick, and other sources. Trusted runtime context determines the origin; a model-provided origin cannot elevate access.
+Results are condensed before returning to Lumi AI:
-Twitch is limited to compact output and at most two source references. Discord permits moderate detail. WebUI permits richer summaries and more results. The tool also applies a per-actor, per-origin, per-server/channel rolling request limit.
+- WebUI may use richer context and multiple sources
+- Discord receives compact context
+- Twitch receives a very short result with at most one source reference when enabled
-## Auditing and storage
+The final Lumi response formatter still applies the platform's authoritative message limit.
-All writable data remains under this plugin:
+## Caching, limits, and diagnostics
-- `data/settings.json`: normalized settings and provider secret
-- `data/audit.jsonl`: query, reason, actor, origin, server/channel, policy outcome, result count, cache status, and timing
+Cache entries are stored in `data/cache/` and expire according to the configured TTL. Rate limits apply independently per actor, origin, and server/channel. Rate-limited results include a retry-after value.
-Provider credentials are not written to audit records or returned in tool results. Updates preserve `data/` by default.
+`data/status.json` stores provider health, aggregate counters, cache status, and recent redacted calls. `data/audit.jsonl` records actor, role, origin, capability, safe query summary/hash, reason, provider, policy decision, result count, cache state, timing, blocked reason, and status. Full page content and secrets are not logged.
-## Security boundary
+## Optional external provider
-The plugin has no shell, SQL, arbitrary filesystem, browser automation, or code-execution feature. Network access is limited to the configured public search provider and policy-approved public result pages. Lumi AI's backend role and permission checks remain authoritative.
+Select `external_json` only when an administrator explicitly wants a compatible SearxNG or generic JSON endpoint. External provider settings are advanced and are not required for default operation. Selecting external mode without an endpoint blocks only search discovery; explicit URL tools remain available.
+
+## Browser and sidecar modes
+
+Headless browser fallback is disabled and not implemented as a default path. The setting is reserved for a future restricted Lumi-managed runtime. A future local sidecar can be added behind the provider abstraction without changing tool contracts; default operation will continue to work without it.
+
+## Troubleshooting
+
+- **Search unavailable but URL fetch works:** a public search adapter may be blocked or rate-limited. Check provider health and recent adapter errors.
+- **URL blocked:** inspect blacklist/whitelist rules. Hard private-network blocks cannot be overridden.
+- **External provider not configured:** select `lumi_search_broker` or configure the optional endpoint.
+- **Rate limited:** wait for the returned retry-after interval.
+- **No readable content:** the page may be JavaScript-only or use an unsupported content type. Browser fallback is intentionally off.
## Verification
@@ -90,4 +136,4 @@ Run:
node plugins/lumi_ai_web_search/tests/verify.js
```
-The suite covers whitelist/blacklist matching, hard private-network blocks, redirect checks, reason-aware formatting, origin budgets, provider failures, settings effects, registration availability, and audits.
+The suite covers default no-key availability, three-capability registration, prompt exposure compatibility, broker adapters, URL policy, redirects, private-network blocking, readable extraction, output budgets, caching, rate limits, audits, and clean failure behavior.
diff --git a/plugins/lumi_ai_web_search/tests/verify.js b/plugins/lumi_ai_web_search/tests/verify.js
index 1372eb6..29b61c0 100644
--- a/plugins/lumi_ai_web_search/tests/verify.js
+++ b/plugins/lumi_ai_web_search/tests/verify.js
@@ -2,35 +2,371 @@ const assert = require("assert");
const fs = require("fs");
const os = require("os");
const path = require("path");
-const { SearchProvider } = require("../backend/provider_adapter");
+const zlib = require("zlib");
+const { parseBingRss } = require("../backend/adapters/bing_rss_search");
+const { parseDuckDuckGoHtml } = require("../backend/adapters/generic_html_search");
+const { ToolCache } = require("../backend/cache");
+const { extractReadableHtml } = require("../backend/html_extractor");
+const { LumiSearchBroker, normalizeBrokerResults } = require("../backend/lumi_search_broker");
+const { PageFetcher } = require("../backend/page_fetcher");
+const { ToolConcurrency } = require("../backend/rate_limits");
const { formatResults } = require("../backend/result_formatter");
const { WebSearchTool } = require("../backend/search_tool");
-const { readSettings, writeSettings } = require("../backend/settings");
+const { defaults, readSettings, writeSettings } = require("../backend/settings");
const { evaluateUrl, matchesRule } = require("../backend/url_policy");
const { ToolRegistry } = require("../../lumi_ai/backend/tool_router");
const { ToolInstaller } = require("../../lumi_ai/backend/tool_installer");
const { ToolLoader } = require("../../lumi_ai/backend/tool_loader");
+const { ToolManager } = require("../../lumi_ai/backend/tool_manager");
+const { ToolSettings } = require("../../lumi_ai/backend/tool_settings");
+const { buildPrompt } = require("../../lumi_ai/backend/prompt_builder");
const plugin = require("../index");
const PUBLIC_DNS = async () => ["93.184.216.34"];
async function run() {
+ verifyDefaultsAndMigration();
await verifyPolicy();
- await verifyRedirectPolicy();
+ verifyExtractionAndAdapters();
+ await verifyFetcher();
verifyFormatting();
- await verifySearchFlow();
+ await verifySearchAndCache();
+ await verifyProviderFailure();
+ await verifyFetchCapabilities();
+ await verifyRateLimit();
+ await verifyConcurrencyLimit();
await verifyLoaderLifecycle();
- verifyRegistrationAvailability();
+ verifyRegistrationAndPrompt();
verifyStaticFiles();
console.log("Lumi AI Web Search verification passed.");
}
+function verifyDefaultsAndMigration() {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-defaults-"));
+ const fresh = readSettings(root);
+ assert.equal(fresh.provider, "lumi_search_broker");
+ assert.equal(fresh.enable_search, true);
+ assert.equal(fresh.policy_mode, "blacklist");
+ assert.deepEqual(fresh.allowed_origins, ["webui", "discord", "twitch"]);
+ fs.writeFileSync(path.join(root, "settings.json"), JSON.stringify({
+ enabled: false,
+ policy_mode: "whitelist",
+ url_rules: ["docs.example.com"],
+ provider_endpoint: ""
+ }));
+ const migrated = readSettings(root);
+ assert.equal(migrated.provider, "lumi_search_broker");
+ assert.equal(migrated.enable_search, false);
+ assert.equal(migrated.policy_mode, "whitelist");
+ assert.deepEqual(migrated.url_rules, ["docs.example.com"]);
+ fs.rmSync(root, { recursive: true, force: true });
+}
+
+async function verifyPolicy() {
+ assert.equal((await evaluateUrl("https://docs.example.com/guide", {
+ mode: "whitelist",
+ rules: ["*.example.com/*"],
+ resolveHost: PUBLIC_DNS
+ })).allowed, true);
+ assert.equal((await evaluateUrl("https://unrelated.test/guide", {
+ mode: "whitelist",
+ rules: ["*.example.com/*"],
+ resolveHost: PUBLIC_DNS
+ })).reason, "not_whitelisted");
+ assert.equal((await evaluateUrl("https://ads.example.com/tracker", {
+ mode: "blacklist",
+ rules: ["*.example.com/tracker*"],
+ resolveHost: PUBLIC_DNS
+ })).reason, "blacklisted");
+ for (const target of [
+ "http://127.0.0.1/",
+ "http://10.1.2.3/",
+ "http://169.254.169.254/latest/meta-data/",
+ "http://localhost/",
+ "file:///etc/passwd",
+ "javascript:alert(1)",
+ "data:text/plain,no"
+ ]) {
+ assert.equal((await evaluateUrl(target, {
+ mode: "blacklist",
+ rules: [],
+ resolveHost: PUBLIC_DNS
+ })).allowed, false, target);
+ }
+ assert.equal((await evaluateUrl("https://dns-rebind.example/", {
+ mode: "blacklist",
+ rules: [],
+ resolveHost: async () => ["10.0.0.8"]
+ })).reason, "private_network");
+ assert.equal(matchesRule(new URL("https://docs.example.com/guide/start"), "example.com/guide"), true);
+}
+
+function verifyExtractionAndAdapters() {
+ const html = `
+ Example & Test
+
+
+ Heading
Readable body text.
+ `;
+ const extracted = extractReadableHtml(html, { maxChars: 500 });
+ assert.equal(extracted.title, "Example & Test");
+ assert.match(extracted.extracted_text, /Readable body text/);
+ assert.doesNotMatch(extracted.extracted_text, /secret|Noise/);
+ assert.equal(extracted.published_at, "2026-06-10T12:00:00.000Z");
+
+ const ddg = parseDuckDuckGoHtml(`
+ Official docs
+ Current documentation result.`);
+ assert.equal(ddg[0].url, "https://docs.example.com/guide");
+ assert.equal(ddg[0].snippet, "Current documentation result.");
+
+ const bing = parseBingRss(`
+ - Releasehttps://example.com/release
+ Latest release details.Wed, 10 Jun 2026 12:00:00 GMT
`);
+ assert.equal(bing[0].domain, undefined);
+ assert.equal(bing[0].url, "https://example.com/release");
+
+ const normalized = normalizeBrokerResults([
+ { title: "Docs", url: "https://example.com/a?utm_source=x", snippet: "A", source: "one" },
+ { title: "Docs", url: "https://example.com/a", snippet: "B", source: "two" }
+ ]);
+ assert.equal(normalized.length, 1);
+ assert.equal(normalized[0].url, "https://example.com/a");
+}
+
+async function verifyFetcher() {
+ const html = "Page titleReadable page.";
+ const compressed = zlib.gzipSync(Buffer.from(html));
+ let call = 0;
+ const fetcher = new PageFetcher({
+ resolveHost: PUBLIC_DNS,
+ fetch: async () => {
+ call += 1;
+ if (call === 1) return response({ status: 302, headers: { location: "https://docs.example.com/final" } });
+ return response({
+ headers: { "content-type": "text/html; charset=utf-8", "content-encoding": "gzip" },
+ body: compressed
+ });
+ }
+ });
+ const page = await fetcher.fetchPage("https://docs.example.com/start", testSettings({
+ policy_mode: "whitelist",
+ url_rules: ["*.example.com/*"]
+ }));
+ assert.equal(page.final_url, "https://docs.example.com/final");
+ assert.equal(page.title, "Page title");
+ assert.match(page.extracted_text, /Readable page/);
+
+ const blockedRedirect = new PageFetcher({
+ resolveHost: PUBLIC_DNS,
+ fetch: async () => response({ status: 302, headers: { location: "http://127.0.0.1/private" } })
+ });
+ await assert.rejects(
+ () => blockedRedirect.fetchPage("https://docs.example.com/start", testSettings()),
+ /blocked by policy/i
+ );
+
+ const oversized = new PageFetcher({
+ resolveHost: PUBLIC_DNS,
+ fetch: async () => response({
+ headers: { "content-type": "text/html" },
+ body: Buffer.alloc(70000, "a")
+ })
+ });
+ await assert.rejects(
+ () => oversized.fetchPage("https://example.com/large", testSettings({ max_fetch_bytes: 65536 })),
+ /size limit/i
+ );
+}
+
+function verifyFormatting() {
+ const rows = [
+ result("Community", "https://community.example.com/post", "Community context.", "web"),
+ result("Official docs", "https://docs.example.com/guide", "Official answer.", "documentation"),
+ result("Recent", "https://news.example.com/update", "Recent update.", "news", "2026-06-12")
+ ];
+ const settings = testSettings();
+ const twitch = formatResults(rows, { reason: "fact_lookup", origin: "twitch", settings });
+ const discord = formatResults(rows, { reason: "resource_lookup", origin: "discord", settings });
+ const webui = formatResults(rows, { reason: "documentation_lookup", origin: "webui", settings });
+ assert(twitch.condensed_text.length <= settings.twitch_output_chars);
+ assert.equal(twitch.results.length, 1);
+ assert.equal(twitch.results[0].url, null);
+ assert(discord.condensed_text.length <= settings.discord_output_chars);
+ assert(webui.condensed_text.length <= settings.webui_output_chars);
+ assert.equal(webui.results[0].title, "Official docs");
+}
+
+async function verifySearchAndCache() {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-search-"));
+ writeSettings(root, testSettings({
+ policy_mode: "whitelist",
+ url_rules: ["*.example.com/*"],
+ cache_ttl_seconds: 60
+ }));
+ let calls = 0;
+ const broker = {
+ async search() {
+ calls += 1;
+ return {
+ provider: "lumi_search_broker",
+ results: [
+ result("Verified fact", "https://docs.example.com/fact", "The answer is current.", "documentation"),
+ result("Blocked local", "http://127.0.0.1/private", "Never return.", "web")
+ ],
+ warnings: [],
+ adapter_errors: []
+ };
+ }
+ };
+ const tool = new WebSearchTool({
+ dataDir: root,
+ broker,
+ fetcher: new PageFetcher({ resolveHost: PUBLIC_DNS })
+ });
+ const input = {
+ query: "current fact",
+ reason: "fact_lookup",
+ user: { id: "user-1", username: "alice" },
+ ctx: { origin: "webui", server_id: "server-1" }
+ };
+ const first = await tool.search(input);
+ assert.equal(first.status, "ok");
+ assert.equal(first.provider, "lumi_search_broker");
+ assert.equal(first.result_count, 1);
+ assert.equal(first.results[0].title, "Verified fact");
+ assert.equal(first.results.some((entry) => entry.url?.includes("127.0.0.1")), false);
+ const cached = await tool.search(input);
+ assert.equal(cached.cache_hit, true);
+ assert.equal(calls, 1);
+ const audit = fs.readFileSync(path.join(root, "audit.jsonl"), "utf8").trim().split(/\r?\n/).map(JSON.parse);
+ assert(audit.some((entry) =>
+ entry.actor === "user-1" &&
+ entry.origin === "webui" &&
+ entry.provider === "lumi_search_broker" &&
+ entry.query_hash &&
+ typeof entry.timing_ms === "number"
+ ));
+ assert.equal(fs.readFileSync(path.join(root, "audit.jsonl"), "utf8").includes("The answer is current"), false);
+ fs.rmSync(root, { recursive: true, force: true });
+}
+
+async function verifyFetchCapabilities() {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-fetch-"));
+ writeSettings(root, testSettings());
+ const page = {
+ url: "https://docs.example.com/page",
+ final_url: "https://docs.example.com/page",
+ title: "Documentation",
+ description: "Description",
+ headings: ["Documentation"],
+ extracted_text: "Readable documentation text with the current answer.",
+ content_type: "text/html",
+ fetched_at: new Date().toISOString(),
+ extraction_status: "ok",
+ published_at: null,
+ updated_at: null,
+ timing_ms: 10,
+ truncated: false
+ };
+ const tool = new WebSearchTool({
+ dataDir: root,
+ fetcher: {
+ resolveHost: PUBLIC_DNS,
+ async fetchPage() { return page; }
+ }
+ });
+ const fetched = await tool.fetchUrl({
+ url: page.url,
+ user: { id: "u" },
+ ctx: { origin: "discord" }
+ });
+ const summarized = await tool.summarizeUrl({
+ url: page.url,
+ user: { id: "u2" },
+ ctx: { origin: "webui" }
+ });
+ assert.equal(fetched.status, "ok");
+ assert.match(fetched.fetched_pages[0].extracted_text, /current answer/);
+ assert.equal(summarized.status, "ok");
+ assert.match(summarized.condensed_text, /Readable documentation/);
+ fs.rmSync(root, { recursive: true, force: true });
+}
+
+async function verifyProviderFailure() {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-failure-"));
+ writeSettings(root, testSettings());
+ const tool = new WebSearchTool({
+ dataDir: root,
+ broker: {
+ async search() {
+ return {
+ provider: "lumi_search_broker",
+ results: [],
+ warnings: ["duckduckgo_html: timed out"],
+ adapter_errors: [{ adapter: "duckduckgo_html", reason: "timed out" }]
+ };
+ }
+ },
+ fetcher: new PageFetcher({ resolveHost: PUBLIC_DNS })
+ });
+ const result = await tool.search({
+ query: "current unavailable fact",
+ reason: "fact_lookup",
+ user: { id: "failure" },
+ ctx: { origin: "webui" }
+ });
+ assert.equal(result.status, "unavailable");
+ assert.match(result.user_message, /unavailable/i);
+ fs.rmSync(root, { recursive: true, force: true });
+}
+
+async function verifyRateLimit() {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-rate-"));
+ writeSettings(root, testSettings({ per_user_per_minute: 1 }));
+ const tool = new WebSearchTool({
+ dataDir: root,
+ broker: {
+ async search() {
+ return { provider: "lumi_search_broker", results: [], warnings: [], adapter_errors: [] };
+ }
+ },
+ fetcher: new PageFetcher({ resolveHost: PUBLIC_DNS })
+ });
+ const input = {
+ query: "one",
+ reason: "general_lookup",
+ user: { id: "limited" },
+ ctx: { origin: "webui", server_id: "server" }
+ };
+ await tool.search(input);
+ const limited = await tool.search({ ...input, query: "two" });
+ assert.equal(limited.blocked_reason, "rate_limited");
+ assert(limited.retry_after_seconds > 0);
+ assert.match(limited.user_message, /Retry in/);
+ fs.rmSync(root, { recursive: true, force: true });
+}
+
+async function verifyConcurrencyLimit() {
+ const limiter = new ToolConcurrency(2, 4);
+ let active = 0;
+ let maximum = 0;
+ const tasks = Array.from({ length: 6 }, () => limiter.run(async () => {
+ active += 1;
+ maximum = Math.max(maximum, active);
+ await new Promise((resolve) => setTimeout(resolve, 5));
+ active -= 1;
+ }));
+ await Promise.all(tasks);
+ assert.equal(maximum, 2);
+}
+
async function verifyLoaderLifecycle() {
const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-loader-"));
const pluginsDir = path.join(root, "plugins");
const toolDir = path.join(pluginsDir, "lumi_ai_web_search");
- copyDirectory(path.resolve(__dirname, ".."), toolDir, new Set(["data"]));
- fs.mkdirSync(path.join(toolDir, "data"), { recursive: true });
+ copyDirectory(path.resolve(__dirname, ".."), toolDir, new Set(["audit.jsonl", "status.json"]));
+ fs.rmSync(path.join(toolDir, "data", "settings.json"), { force: true });
const installer = new ToolInstaller({
pluginsDir,
stagingRoot: path.join(root, "staging"),
@@ -42,276 +378,166 @@ async function verifyLoaderLifecycle() {
installer,
settings: { getSetting: (_key, fallback) => fallback },
stateFile: path.join(root, "enabled.json"),
- lumiAiVersion: "0.8.0",
+ lumiAiVersion: "0.8.1",
lumiVersion: "0.1.0"
});
- const unavailable = await loader.enable("lumi_ai_web_search");
- assert.equal(unavailable.unavailable, true);
- assert.equal(registry.tools.has("lumi_ai_web_search.search"), false);
- writeSettings(path.join(toolDir, "data"), providerSettings());
- const enabled = await loader.enable("lumi_ai_web_search");
- assert.equal(enabled.loaded, true);
- assert.equal(registry.tools.has("lumi_ai_web_search.search"), true);
+ await loader.loadEnabled();
+ assert.equal(fs.existsSync(path.join(toolDir, "data", "settings.json")), true);
+ assert.equal(loader.isEnabled("lumi_ai_web_search"), true);
+ assert.equal(registry.has("web_search.search"), true);
+ assert.equal(registry.has("web_search.fetch_url"), true);
+ assert.equal(registry.has("web_search.summarize_url"), true);
+ const manager = new ToolManager({
+ loader,
+ installer,
+ settings: new ToolSettings({ installer }),
+ repoClient: {
+ async discover() {
+ return {
+ repository: "local",
+ branch: "main",
+ checked_at: new Date().toISOString(),
+ cached: false,
+ stale: false,
+ tools: []
+ };
+ }
+ }
+ });
+ const diagnostics = await manager.diagnostics({
+ role: "admin",
+ user: { id: "admin", isAdmin: true },
+ context: { origin: "webui", permission_context: { webui_actions_allowed: true } }
+ });
+ const pluginDiagnostics = diagnostics.plugins.find((entry) => entry.tool_id === "lumi_ai_web_search");
+ assert.equal(pluginDiagnostics.runtime_details.provider, "lumi_search_broker");
+ assert.equal(pluginDiagnostics.decisions.length, 3);
+ assert(pluginDiagnostics.decisions.every((decision) => decision.exposed));
+ assert(diagnostics.considered_tools.includes("web_search.search"));
+ assert(diagnostics.exposed_tools.includes("web_search.search"));
+ const described = manager.settingsFor("lumi_ai_web_search");
+ assert.equal(described.values.provider, "lumi_search_broker");
+ assert(described.ui.html.includes("data-web-search-settings"));
+ assert(described.ui.scripts.some((value) => value.endsWith("/settings-modal.js")));
+ assert(described.ui.styles.some((value) => value.endsWith("/settings-modal.css")));
await loader.disable("lumi_ai_web_search");
- assert.equal(registry.tools.has("lumi_ai_web_search.search"), false);
+ assert.equal(registry.has("web_search.search"), false);
fs.rmSync(root, { recursive: true, force: true });
}
-async function verifyPolicy() {
- let result = await evaluateUrl("https://docs.example.com/guide", {
- mode: "whitelist",
- rules: ["*.example.com/*"],
- resolveHost: PUBLIC_DNS
- });
- assert.equal(result.allowed, true);
- result = await evaluateUrl("https://unrelated.test/guide", {
- mode: "whitelist",
- rules: ["*.example.com/*"],
- resolveHost: PUBLIC_DNS
- });
- assert.equal(result.allowed, false);
- assert.equal(result.reason, "not_whitelisted");
-
- result = await evaluateUrl("https://ads.example.com/tracker", {
- mode: "blacklist",
- rules: ["*.example.com/tracker*"],
- resolveHost: PUBLIC_DNS
- });
- assert.equal(result.allowed, false);
- result = await evaluateUrl("https://docs.example.org/", {
- mode: "blacklist",
- rules: ["*.example.com/tracker*"],
- resolveHost: PUBLIC_DNS
- });
- assert.equal(result.allowed, true);
-
- for (const target of [
- "http://127.0.0.1/",
- "http://10.1.2.3/",
- "http://169.254.169.254/latest/meta-data/",
- "http://localhost/",
- "file:///etc/passwd"
- ]) {
- result = await evaluateUrl(target, {
- mode: "blacklist",
- rules: [],
- resolveHost: PUBLIC_DNS
- });
- assert.equal(result.allowed, false, target);
- }
- result = await evaluateUrl("https://dns-rebind.example/", {
- mode: "blacklist",
- rules: [],
- resolveHost: async () => ["10.0.0.8"]
- });
- assert.equal(result.allowed, false);
- assert.equal(matchesRule(new URL("https://docs.example.com/guide/start"), "example.com/guide"), true);
- assert.equal(matchesRule(new URL("https://example.com/"), "http://example.com/"), false);
-}
-
-async function verifyRedirectPolicy() {
- const provider = new SearchProvider({
- resolveHost: PUBLIC_DNS,
- fetch: async () => response({
- status: 302,
- headers: { location: "http://127.0.0.1/private" }
- })
- });
- await assert.rejects(
- () => provider.search("test", providerSettings()),
- /blocked by policy/i
- );
- let calls = 0;
- const crossOrigin = new SearchProvider({
- resolveHost: PUBLIC_DNS,
- fetch: async () => {
- calls += 1;
- return response({
- status: 302,
- headers: { location: "https://other-provider.example/search" }
- });
- }
- });
- await assert.rejects(
- () => crossOrigin.search("test", { ...providerSettings(), provider_api_key: "secret" }),
- /cross_origin_provider_redirect/i
- );
- assert.equal(calls, 1);
-}
-
-function verifyFormatting() {
- const rows = [
- result("Official docs", "https://docs.example.com/guide", "A detailed official answer for the requested subject.", "documentation"),
- result("Community post", "https://community.example.com/post", "A secondary explanation with useful context.", "web"),
- result("Recent update", "https://news.example.com/update", "A recently published update.", "news", "2026-06-12")
- ];
- const settings = {
- max_results: 5,
- show_source_links: true,
- twitch_output_chars: 180,
- discord_output_chars: 700,
- webui_output_chars: 3000,
- other_output_chars: 500
- };
- const fact = formatResults(rows, { reason: "fact_lookup", origin: "twitch", settings });
- const resource = formatResults(rows, { reason: "resource_lookup", origin: "discord", settings });
- const webui = formatResults(rows, { reason: "documentation_lookup", origin: "webui", settings });
- assert(fact.condensed_text.length <= 180);
- assert(fact.results.length <= 2);
- assert(resource.condensed_text.length <= 700);
- assert(webui.condensed_text.length > fact.condensed_text.length);
- assert.equal(webui.results[0].source_type, "documentation");
-}
-
-async function verifySearchFlow() {
- const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-search-"));
- const settings = {
- ...providerSettings(),
- enabled: true,
- policy_mode: "whitelist",
- url_rules: ["*.example.com/*"],
- allowed_origins: ["webui", "discord", "twitch"],
- cache_ttl_seconds: 60
- };
- writeSettings(root, settings);
- let calls = 0;
- const provider = {
- resolveHost: PUBLIC_DNS,
- async search() {
- calls += 1;
- return [
- result("Verified fact", "https://docs.example.com/fact", "The answer is current.", "documentation"),
- result("Blocked local", "http://127.0.0.1/private", "Must never be returned.", "web")
- ];
- },
- async fetchPage() {
- return { url: "https://docs.example.com/fact", text: "Expanded public page text." };
- }
- };
- const tool = new WebSearchTool({ dataDir: root, provider });
- const first = await tool.run({
- query: "current fact",
- reason: "fact_lookup",
- user: { id: "user-1" },
- ctx: { origin: "webui", server_id: "server-1" }
- });
- assert.equal(first.status, "ok");
- assert.equal(first.result_count, 1);
- assert.equal(first.results[0].title, "Verified fact");
- assert.equal(first.results.some((entry) => entry.url?.includes("127.0.0.1")), false);
- const cached = await tool.run({
- query: "current fact",
- reason: "fact_lookup",
- user: { id: "user-1" },
- ctx: { origin: "webui", server_id: "server-1" }
- });
- assert.equal(cached.cache_hit, true);
- assert.equal(calls, 1);
-
- const twitch = await tool.run({
- query: "current fact twitch",
- reason: "resource_lookup",
- user: { id: "user-1" },
- ctx: { origin: "twitch", channel_id: "channel-1" }
- });
- assert(twitch.condensed_text.length <= readSettings(root).twitch_output_chars);
- assert.equal(calls, 2);
-
- writeSettings(root, { ...readSettings(root), allowed_origins: ["webui"] });
- const blockedOrigin = await tool.run({
- query: "current fact",
- reason: "fact_lookup",
- origin: "webui",
- user: { id: "user-1" },
- ctx: { origin: "discord" }
- });
- assert.equal(blockedOrigin.status, "blocked");
- assert.equal(blockedOrigin.blocked_reason, "origin_not_allowed");
-
- const failing = new WebSearchTool({
- dataDir: root,
- provider: {
- resolveHost: PUBLIC_DNS,
- async search() { throw new Error("provider secret https://provider.example/api?token=secret"); }
- }
- });
- const failed = await failing.run({
- query: "failure",
- reason: "general_lookup",
- user: { id: "user-2" },
- ctx: { origin: "webui" }
- });
- assert.equal(failed.status, "unavailable");
- assert.equal(failed.error.includes("provider.example"), false);
-
- const audit = fs.readFileSync(path.join(root, "audit.jsonl"), "utf8")
- .trim().split(/\r?\n/).map(JSON.parse);
- assert(audit.some((entry) =>
- entry.query === "current fact" &&
- entry.actor === "user-1" &&
- entry.origin === "webui" &&
- typeof entry.timing_ms === "number"
- ));
- fs.rmSync(root, { recursive: true, force: true });
-}
-
-function verifyRegistrationAvailability() {
+function verifyRegistrationAndPrompt() {
const root = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-web-register-"));
- assert.equal(plugin.checkAvailability({ paths: { data: root } }).available, false);
- writeSettings(root, { ...providerSettings(), enabled: true });
+ writeSettings(root, testSettings());
assert.equal(plugin.checkAvailability({ paths: { data: root } }).available, true);
const definitions = [];
plugin.register({
paths: { data: root },
registerTool: (definition) => definitions.push(definition)
});
- assert.equal(definitions.length, 1);
- assert.equal(definitions[0].tool_id, "lumi_ai_web_search.search");
- assert.equal(definitions[0].read_only, true);
- assert.equal(definitions[0].origin_check({
+ assert.deepEqual(definitions.map((definition) => definition.tool_id), [
+ "web_search.search",
+ "web_search.fetch_url",
+ "web_search.summarize_url"
+ ]);
+ assert(definitions.every((definition) => definition.read_only === true));
+ assert(definitions[0].origin_check({
context: { origin: "discord", permission_context: { webui_actions_allowed: false } }
- }), true);
- assert.equal(definitions[0].permission_check({
- user: { id: "user" },
- context: { origin: "discord", permission_context: { webui_actions_allowed: false } }
- }), true);
+ }));
+ const registry = new ToolRegistry(() => {});
+ const metadata = require("../tool_info.json");
+ const { registerManagedTool } = require("../../lumi_ai/backend/tool_registry");
+ for (const definition of definitions) registerManagedTool(registry, metadata, definition);
+ const exposed = registry.inspect({
+ role: "admin",
+ user: { id: "admin", isAdmin: true },
+ context: { origin: "webui", permission_context: { webui_actions_allowed: true } }
+ }).exposed;
+ const prompt = buildPrompt({
+ config: { support_scope: {}, instructions: { roleplay_intensity: 0 } },
+ role: "admin",
+ message: "Find the latest release",
+ tools: exposed,
+ originContext: { origin: "webui" }
+ });
+ assert(prompt.includes('"tool_id":"web_search.search"'));
+ assert(prompt.includes("WEB SEARCH DECISION RULES"));
+ assert(prompt.includes('{"type":"tool_call","tool":"tool_id","arguments":{}}'));
+
+ writeSettings(root, testSettings({ enable_search: false }));
+ const fetchOnly = [];
+ plugin.register({
+ paths: { data: root },
+ registerTool: (definition) => fetchOnly.push(definition)
+ });
+ assert.equal(fetchOnly.some((definition) => definition.tool_id === "web_search.search"), false);
+ assert.equal(fetchOnly.some((definition) => definition.tool_id === "web_search.fetch_url"), true);
+
+ writeSettings(root, testSettings({
+ provider: "external_json",
+ external_provider_endpoint: ""
+ }));
+ const externalWithoutEndpoint = [];
+ plugin.register({
+ paths: { data: root },
+ registerTool: (definition) => externalWithoutEndpoint.push(definition)
+ });
+ assert.equal(externalWithoutEndpoint.some((definition) => definition.tool_id === "web_search.search"), false);
+ assert.equal(externalWithoutEndpoint.some((definition) => definition.tool_id === "web_search.fetch_url"), true);
fs.rmSync(root, { recursive: true, force: true });
}
function verifyStaticFiles() {
const root = path.resolve(__dirname, "..");
- const metadata = JSON.parse(fs.readFileSync(path.join(root, "tool_info.json"), "utf8"));
- assert.equal(metadata.tool_id, "lumi_ai_web_search");
- assert.equal(metadata.settings_schema.policy_mode.default, "whitelist");
- assert(fs.existsSync(path.join(root, "readme.md")));
- assert(fs.readFileSync(path.join(root, "views", "settings-modal.ejs"), "utf8").includes("settings_schema"));
+ const metadata = require("../tool_info.json");
+ assert.equal(metadata.version, "1.1.0");
+ assert.equal(metadata.settings_schema.provider.default, "lumi_search_broker");
+ assert.equal(metadata.settings_schema.policy_mode.default, "blacklist");
+ assert.equal(metadata.default_enabled, true);
+ assert(fs.existsSync(path.join(root, "backend", "lumi_search_broker.js")));
+ assert(fs.existsSync(path.join(root, "backend", "page_fetcher.js")));
+ assert(fs.existsSync(path.join(root, "public", "settings-modal.css")));
+ assert(fs.readFileSync(path.join(root, "readme.md"), "utf8").includes("without requiring an API key"));
}
-function providerSettings() {
+function testSettings(overrides = {}) {
return {
- ...Object.fromEntries(
- Object.entries(require("../tool_info.json").settings_schema).map(([key, field]) => [key, structuredClone(field.default)])
- ),
- provider_endpoint: "https://search.example.net/search",
- enabled: true,
- allowed_origins: ["webui", "discord", "twitch"],
- url_rules: ["*.example.com/*"]
+ ...defaults(),
+ ...overrides,
+ provider: overrides.provider || "lumi_search_broker",
+ enable_search: overrides.enable_search ?? true,
+ enable_fetch_url: overrides.enable_fetch_url ?? true,
+ enable_summarize_url: overrides.enable_summarize_url ?? true,
+ policy_mode: overrides.policy_mode || "blacklist",
+ allowed_origins: overrides.allowed_origins || ["webui", "discord", "twitch"]
};
}
-function result(title, url, snippet, sourceType, date = null) {
- return { title, url, snippet, source_type: sourceType, date, relevance_score: 0.9 };
+function result(title, url, snippet, source, date = null) {
+ return {
+ title,
+ url,
+ domain: new URL(url).hostname,
+ snippet,
+ date,
+ rank: 1,
+ source,
+ raw_source_id: "test",
+ relevance_score: 0.9
+ };
}
-function response({ status = 200, headers = {}, body = "" }) {
- const normalized = Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+function response({ status = 200, headers = {}, body = Buffer.from("") }) {
+ const normalized = Object.fromEntries(
+ Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value])
+ );
+ const buffer = Buffer.from(body);
return {
ok: status >= 200 && status < 300,
status,
headers: {
get(name) { return normalized[String(name).toLowerCase()] || null; }
},
- async arrayBuffer() { return Buffer.from(body); }
+ async arrayBuffer() { return buffer; }
};
}
@@ -321,7 +547,7 @@ function copyDirectory(source, destination, ignored = new Set()) {
if (ignored.has(entry.name)) continue;
const from = path.join(source, entry.name);
const to = path.join(destination, entry.name);
- if (entry.isDirectory()) copyDirectory(from, to);
+ if (entry.isDirectory()) copyDirectory(from, to, ignored);
else if (entry.isFile()) fs.copyFileSync(from, to);
}
}
diff --git a/plugins/lumi_ai_web_search/tool_info.json b/plugins/lumi_ai_web_search/tool_info.json
index 9dfc41a..bd91927 100644
--- a/plugins/lumi_ai_web_search/tool_info.json
+++ b/plugins/lumi_ai_web_search/tool_info.json
@@ -1,31 +1,51 @@
{
"tool_id": "lumi_ai_web_search",
+ "tool_namespace": "web_search",
"name": "lumi_ai_web_search",
"display_name": "Lumi AI Web Search",
- "version": "1.0.1",
- "description": "Controlled current-information search for Lumi Assistant with URL policy, origin budgets, and source normalization.",
+ "version": "1.1.0",
+ "description": "Self-contained, policy-controlled public web search and safe URL extraction for Lumi Assistant. The default provider requires no API key or external service setup.",
"scope": {
- "label": "Assistant web lookup",
+ "label": "Assistant public web lookup",
"required_role": "user"
},
"permissions": {
"required_role": "user",
- "permission": "lumi_ai_web_search.search"
+ "permission": "lumi_ai_web_search.use"
},
"capabilities": [
- "Current web search through an administrator-configured JSON search provider",
+ "No-key public web search through the tool-contained Lumi search broker",
+ "Safe explicit URL fetch and readable-text extraction",
+ "Condensed URL summarization",
"Whitelist or blacklist URL policy with wildcard rules",
- "Optional bounded page excerpt fetching",
- "Context-aware condensed results for WebUI and chat platforms"
+ "Context-aware output budgets, caching, rate limits, diagnostics, and audits"
+ ],
+ "registered_capabilities": [
+ {
+ "tool_id": "web_search.search",
+ "enabled_setting": "enable_search",
+ "description": "Search the public web for current or external information."
+ },
+ {
+ "tool_id": "web_search.fetch_url",
+ "enabled_setting": "enable_fetch_url",
+ "description": "Fetch and extract readable information from an explicit public URL."
+ },
+ {
+ "tool_id": "web_search.summarize_url",
+ "enabled_setting": "enable_summarize_url",
+ "description": "Fetch an explicit public URL and return compact structured content for summarization."
+ }
],
"limitations": [
- "Requires an administrator-configured search provider endpoint",
- "Does not provide browser automation or execute page scripts",
- "Private, local, link-local, metadata, and non-HTTP targets are always blocked",
- "Search quality and freshness depend on the configured provider"
+ "Search sources may rate-limit, block automated requests, or change markup",
+ "No JavaScript execution or browser automation is enabled by default",
+ "Private, local, link-local, metadata, credential-bearing, and non-HTTP targets are always blocked",
+ "Search quality and freshness depend on public source availability"
],
"tool_type": "web_search",
"owning_plugin": "lumi_ai_web_search",
+ "default_enabled": true,
"entrypoints": {
"backend": "index.js"
},
@@ -35,9 +55,28 @@
"views": [
"views/settings-modal.ejs"
],
+ "settings_ui": {
+ "view": "views/settings-modal.ejs",
+ "scripts": [
+ "settings-modal.js"
+ ],
+ "styles": [
+ "settings-modal.css"
+ ]
+ },
+ "settings_migrator": "backend/settings.js",
+ "diagnostic_settings": [
+ "provider",
+ "policy_mode",
+ "allowed_origins",
+ "enable_search",
+ "enable_fetch_url",
+ "enable_summarize_url"
+ ],
+ "status_file": "data/status.json",
"dependencies": [],
"minimum_lumi_version": "0.1.0",
- "minimum_lumi_ai_version": "0.8.0",
+ "minimum_lumi_ai_version": "0.8.1",
"required_plugins": [
"core",
"lumi_ai"
@@ -47,36 +86,63 @@
"confirmation_required": false,
"data_paths": [
"data/settings.json",
- "data/audit.jsonl"
+ "data/status.json",
+ "data/audit.jsonl",
+ "data/cache"
],
"preserve_on_update": [
"data"
],
- "update_notes": "Registers as a read-only lookup tool with context-aware prompt exposure for Lumi AI 0.8.0.",
+ "update_notes": "Adds a self-contained no-key search broker plus independent search, fetch URL, and summarize URL capabilities.",
"author": "Lumi",
"homepage": "https://git.rolfsvaag.no/Rolfsvaag_Datateknikk/Lumi",
"repository_path": "plugins/lumi_ai_web_search",
"settings_schema": {
- "enabled": {
+ "provider": {
+ "type": "enum",
+ "label": "Provider",
+ "description": "The default Lumi search broker is contained in this plugin and requires no API key or separate service.",
+ "options": [
+ "lumi_search_broker",
+ "external_json"
+ ],
+ "default": "lumi_search_broker"
+ },
+ "enable_search": {
"type": "boolean",
- "label": "Web search enabled",
- "description": "The tool remains unavailable to Lumi Assistant until this and the parent Tools enable state are both on.",
+ "label": "Enable web search",
+ "default": true
+ },
+ "enable_fetch_url": {
+ "type": "boolean",
+ "label": "Enable explicit URL fetch",
+ "default": true
+ },
+ "enable_summarize_url": {
+ "type": "boolean",
+ "label": "Enable URL summarization",
+ "default": true
+ },
+ "enable_headless_browser_fallback": {
+ "type": "boolean",
+ "label": "Headless browser fallback",
+ "description": "Reserved for a future Lumi-managed restricted browser runtime. HTTP mode works without it.",
"default": false
},
"policy_mode": {
"type": "enum",
- "label": "Search policy",
- "description": "Whitelist permits only matching result/page URLs. Blacklist permits URLs except matching rules.",
+ "label": "URL policy",
+ "description": "Blacklist allows safe public URLs except matching rules. Whitelist permits only matching rules.",
"options": [
- "whitelist",
- "blacklist"
+ "blacklist",
+ "whitelist"
],
- "default": "whitelist"
+ "default": "blacklist"
},
"url_rules": {
"type": "string_list",
"label": "URL policy rules",
- "description": "One domain, URL, path prefix, or * wildcard pattern per line. Example: docs.example.com or *.example.com/docs/*.",
+ "description": "One domain, subdomain, URL, path prefix, or * wildcard pattern per line.",
"default": [],
"rows": 6
},
@@ -94,14 +160,42 @@
"minimum": 1000,
"maximum": 30000
},
+ "fetch_timeout_ms": {
+ "type": "integer",
+ "label": "Page fetch timeout (ms)",
+ "default": 10000,
+ "minimum": 1000,
+ "maximum": 30000
+ },
+ "max_fetch_bytes": {
+ "type": "integer",
+ "label": "Maximum fetched bytes",
+ "default": 1048576,
+ "minimum": 65536,
+ "maximum": 4194304
+ },
+ "max_extracted_chars": {
+ "type": "integer",
+ "label": "Maximum extracted characters",
+ "default": 12000,
+ "minimum": 1000,
+ "maximum": 50000
+ },
+ "max_redirects": {
+ "type": "integer",
+ "label": "Maximum redirects",
+ "default": 3,
+ "minimum": 0,
+ "maximum": 8
+ },
"cache_ttl_seconds": {
"type": "integer",
- "label": "Result cache TTL (seconds)",
- "default": 300,
+ "label": "Cache TTL (seconds)",
+ "default": 900,
"minimum": 0,
- "maximum": 3600
+ "maximum": 86400
},
- "safe_search": {
+ "safe_search_level": {
"type": "enum",
"label": "Safe search",
"options": [
@@ -109,7 +203,7 @@
"moderate",
"strict"
],
- "default": "strict"
+ "default": "moderate"
},
"allowed_origins": {
"type": "multi_select",
@@ -123,13 +217,30 @@
"other"
],
"default": [
- "webui"
+ "webui",
+ "discord",
+ "twitch"
]
},
+ "show_source_links_webui": {
+ "type": "boolean",
+ "label": "Show source links in WebUI",
+ "default": true
+ },
+ "show_source_links_discord": {
+ "type": "boolean",
+ "label": "Show source links in Discord",
+ "default": true
+ },
+ "show_source_links_twitch": {
+ "type": "boolean",
+ "label": "Show source links in Twitch",
+ "default": false
+ },
"webui_output_chars": {
"type": "integer",
"label": "WebUI output budget",
- "default": 4000,
+ "default": 2500,
"minimum": 300,
"maximum": 12000
},
@@ -143,90 +254,91 @@
"twitch_output_chars": {
"type": "integer",
"label": "Twitch output budget",
- "default": 350,
+ "default": 450,
"minimum": 120,
"maximum": 1000
},
"youtube_output_chars": {
"type": "integer",
"label": "YouTube output budget",
- "default": 500,
+ "default": 1200,
"minimum": 120,
- "maximum": 1500
+ "maximum": 3000
},
"kick_output_chars": {
"type": "integer",
"label": "Kick output budget",
- "default": 350,
+ "default": 450,
"minimum": 120,
"maximum": 1000
},
"other_output_chars": {
"type": "integer",
"label": "Other output budget",
- "default": 500,
+ "default": 700,
"minimum": 120,
- "maximum": 2000
+ "maximum": 3000
},
- "provider_adapter": {
+ "per_user_per_minute": {
+ "type": "integer",
+ "label": "Requests per user/minute",
+ "default": 6,
+ "minimum": 1,
+ "maximum": 60
+ },
+ "per_origin_per_minute": {
+ "type": "integer",
+ "label": "Requests per origin/minute",
+ "default": 30,
+ "minimum": 1,
+ "maximum": 300
+ },
+ "per_server_per_minute": {
+ "type": "integer",
+ "label": "Requests per server/minute",
+ "default": 20,
+ "minimum": 1,
+ "maximum": 300
+ },
+ "external_provider_adapter": {
"type": "enum",
- "label": "Provider adapter",
+ "label": "Advanced external adapter",
"options": [
"searxng_json",
"generic_json"
],
"default": "searxng_json"
},
- "provider_endpoint": {
+ "external_provider_endpoint": {
"type": "string",
- "label": "Provider endpoint",
- "description": "HTTPS is recommended. The endpoint must be publicly routable and return JSON.",
+ "label": "Advanced external endpoint",
+ "description": "Optional. Not required by the default Lumi search broker.",
"default": ""
},
- "provider_api_key": {
+ "external_provider_api_key": {
"type": "string",
- "label": "Provider API key",
- "description": "Stored in the plugin data directory and never returned by the settings API.",
+ "label": "Advanced external API key",
"default": "",
"secret": true
},
- "provider_api_key_header": {
+ "external_provider_api_key_header": {
"type": "enum",
- "label": "API key header",
+ "label": "External API key header",
"options": [
"X-API-Key",
"Authorization"
],
"default": "X-API-Key"
},
- "provider_api_key_prefix": {
+ "external_provider_api_key_prefix": {
"type": "string",
- "label": "API key prefix",
- "description": "For example: Bearer",
+ "label": "External API key prefix",
"default": ""
},
- "provider_query_parameter": {
+ "external_provider_query_parameter": {
"type": "string",
- "label": "Query parameter",
+ "label": "External query parameter",
"default": "q"
- },
- "show_source_links": {
- "type": "boolean",
- "label": "Show source links",
- "default": true
- },
- "allow_full_page_fetch": {
- "type": "boolean",
- "label": "Allow page excerpts",
- "description": "Allows bounded text extraction after search discovery. URL policy and redirect checks still apply.",
- "default": false
- },
- "requests_per_minute": {
- "type": "integer",
- "label": "Requests per actor/minute",
- "default": 6,
- "minimum": 1,
- "maximum": 60
}
}
}
diff --git a/plugins/lumi_ai_web_search/views/settings-modal.ejs b/plugins/lumi_ai_web_search/views/settings-modal.ejs
index 34dd8ad..de09505 100644
--- a/plugins/lumi_ai_web_search/views/settings-modal.ejs
+++ b/plugins/lumi_ai_web_search/views/settings-modal.ejs
@@ -1,4 +1,32 @@
-
- Lumi AI renders this tool's settings from tool_info.json settings_schema. Provider secrets are write-only,
- and policy changes apply to WebUI and platform tool calls after saving.
-
+
+
+
Providerlumi_search_broker
+
Provider healthNot tested
+
Policyblacklist
+
Last successNever
+
Last errorNone
+
Cache0 entries
+
+ Recent web tool calls
+ No calls recorded.
+
+
+
+ The default Lumi search broker requires no API key or separately installed search service. Trusted origin and user context are supplied by Lumi, not by model arguments.
+