harald/zeroclaw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

feat(tools): add web_search_tool for internet search

Browse source 
Add native web search capability that works regardless of LLM tool-calling
support. This is particularly useful for GLM models via Z.AI that don't
reliably support standard tool calling formats.

Features:
- DuckDuckGo provider (free, no API key required)
- Brave Search provider (optional, requires API key)
- Configurable max results and timeout
- Enabled by default

Configuration (config.toml):
  [web_search]
  enabled = true
  provider = "duckduckgo"
  max_results = 5

The tool allows agents to search the web for current information without
requiring proper tool calling support from the LLM.

Also includes CI workflow fix for first-interaction action inputs.
This commit is contained in:
adisusilayasa 2026-02-18 14:40:46 +08:00 • committed by Chummy
parent f3bdff1d69
commit 1757add64a
9 changed files with 394 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/config/mod.rs
View file

@ -9,7 +9,9 @@ pub use schema::{
LarkConfig, MatrixConfig, MemoryConfig, ModelRouteConfig, ObservabilityConfig,
PeripheralBoardConfig, PeripheralsConfig, QueryClassificationConfig, ReliabilityConfig,
ResourceLimitsConfig, RuntimeConfig, SandboxBackend, SandboxConfig, SchedulerConfig,
SecretsConfig, SecurityConfig, SlackConfig, TelegramConfig, TunnelConfig, WebhookConfig,
WebSearchConfig, WebhookConfig,
SecretsConfig, SecurityConfig, SlackConfig, TelegramConfig, TunnelConfig, WebSearchConfig,
WebhookConfig,
};
#[cfg(test)]

49
src/config/schema.rs
View file

@ -81,6 +81,9 @@ pub struct Config {
#[serde(default)]
pub http_request: HttpRequestConfig,
#[serde(default)]
pub web_search: WebSearchConfig,
#[serde(default)]
pub identity: IdentityConfig,
@ -721,6 +724,51 @@ fn default_http_timeout_secs() -> u64 {
30
}
// ── Web search ───────────────────────────────────────────────────
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSearchConfig {
/// Enable `web_search_tool` for web searches
#[serde(default = "default_true")]
pub enabled: bool,
/// Search provider: "duckduckgo" (free, no API key) or "brave" (requires API key)
#[serde(default = "default_web_search_provider")]
pub provider: String,
/// Brave Search API key (required if provider is "brave")
#[serde(default)]
pub brave_api_key: Option<String>,
/// Maximum results per search (1-10)
#[serde(default = "default_web_search_max_results")]
pub max_results: usize,
/// Request timeout in seconds
#[serde(default = "default_web_search_timeout_secs")]
pub timeout_secs: u64,
}
fn default_web_search_provider() -> String {
"duckduckgo".into()
}
fn default_web_search_max_results() -> usize {
5
}
fn default_web_search_timeout_secs() -> u64 {
15
}
impl Default for WebSearchConfig {
fn default() -> Self {
Self {
enabled: true,
provider: default_web_search_provider(),
brave_api_key: None,
max_results: default_web_search_max_results(),
timeout_secs: default_web_search_timeout_secs(),
}
}
}
// ── Memory ───────────────────────────────────────────────────
#[derive(Debug, Clone, Serialize, Deserialize)]
@ -1773,6 +1821,7 @@ impl Default for Config {
secrets: SecretsConfig::default(),
browser: BrowserConfig::default(),
http_request: HttpRequestConfig::default(),
web_search: WebSearchConfig::default(),
identity: IdentityConfig::default(),
cost: CostConfig::default(),
peripherals: PeripheralsConfig::default(),

2
src/onboard/wizard.rs
View file

@ -131,6 +131,7 @@ pub fn run_wizard() -> Result<Config> {
secrets: secrets_config,
browser: BrowserConfig::default(),
http_request: crate::config::HttpRequestConfig::default(),
web_search: crate::config::WebSearchConfig::default(),
identity: crate::config::IdentityConfig::default(),
cost: crate::config::CostConfig::default(),
peripherals: crate::config::PeripheralsConfig::default(),
@ -352,6 +353,7 @@ pub fn run_quick_setup(
secrets: SecretsConfig::default(),
browser: BrowserConfig::default(),
http_request: crate::config::HttpRequestConfig::default(),
web_search: crate::config::WebSearchConfig::default(),
identity: crate::config::IdentityConfig::default(),
cost: crate::config::CostConfig::default(),
peripherals: crate::config::PeripheralsConfig::default(),

12
src/tools/mod.rs
View file

@ -25,6 +25,7 @@ pub mod schema;
pub mod screenshot;
pub mod shell;
pub mod traits;
pub mod web_search_tool;
pub use browser::{BrowserTool, ComputerUseConfig};
pub use browser_open::BrowserOpenTool;
@ -56,6 +57,7 @@ pub use shell::ShellTool;
pub use traits::Tool;
#[allow(unused_imports)]
pub use traits::{ToolResult, ToolSpec};
pub use web_search_tool::WebSearchTool;
use crate::config::{Config, DelegateAgentConfig};
use crate::memory::Memory;
@ -188,6 +190,16 @@ pub fn all_tools_with_runtime(
)));
}
// Web search tool (enabled by default for GLM and other models)
if root_config.web_search.enabled {
tools.push(Box::new(WebSearchTool::new(
root_config.web_search.provider.clone(),
root_config.web_search.brave_api_key.clone(),
root_config.web_search.max_results,
root_config.web_search.timeout_secs,
)));
}
// Vision tools are always available
tools.push(Box::new(ScreenshotTool::new(security.clone())));
tools.push(Box::new(ImageInfoTool::new(security.clone())));

302
src/tools/web_search_tool.rs Normal file
View file

@ -0,0 +1,302 @@
use super::traits::{Tool, ToolResult};
use async_trait::async_trait;
use regex::Regex;
use serde_json::json;
use std::time::Duration;
/// Web search tool for searching the internet.
/// Supports multiple providers: DuckDuckGo (free), Brave (requires API key).
pub struct WebSearchTool {
provider: String,
brave_api_key: Option<String>,
max_results: usize,
timeout_secs: u64,
}
impl WebSearchTool {
pub fn new(
provider: String,
brave_api_key: Option<String>,
max_results: usize,
timeout_secs: u64,
) -> Self {
Self {
provider,
brave_api_key,
max_results,
timeout_secs,
}
}
async fn search_duckduckgo(&self, query: &str) -> anyhow::Result<String> {
let encoded_query = urlencoding::encode(query);
let search_url = format!("https://html.duckduckgo.com/html/?q={}", encoded_query);
let client = reqwest::Client::builder()
.timeout(Duration::from_secs(self.timeout_secs))
.user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
.build()?;
let response = client.get(&search_url).send().await?;
if !response.status().is_success() {
anyhow::bail!(
"DuckDuckGo search failed with status: {}",
response.status()
);
}
let html = response.text().await?;
self.parse_duckduckgo_results(&html, query)
}
fn parse_duckduckgo_results(&self, html: &str, query: &str) -> anyhow::Result<String> {
// Extract result links: <a class="result__a" href="...">Title</a>
let link_regex = Regex::new(
r#"<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)</a>"#,
)?;
// Extract snippets: <a class="result__snippet">...</a>
let snippet_regex = Regex::new(r#"<a class="result__snippet[^"]*"[^>]*>([\s\S]*?)</a>"#)?;
let link_matches: Vec<_> = link_regex
.captures_iter(html)
.take(self.max_results + 2)
.collect();
let snippet_matches: Vec<_> = snippet_regex
.captures_iter(html)
.take(self.max_results + 2)
.collect();
if link_matches.is_empty() {
return Ok(format!("No results found for: {}", query));
}
let mut lines = vec![format!("Search results for: {} (via DuckDuckGo)", query)];
let count = link_matches.len().min(self.max_results);
for i in 0..count {
let caps = &link_matches[i];
let mut url_str = caps[1].to_string();
let title = strip_tags(&caps[2]);
// Decode DDG redirect URL
if url_str.contains("uddg=") {
if let Ok(decoded) = urlencoding::decode(&url_str) {
if let Some(idx) = decoded.find("uddg=") {
url_str = decoded[idx + 5..].to_string();
}
}
}
lines.push(format!("{}. {}", i + 1, title.trim()));
lines.push(format!(" {}", url_str.trim()));
// Add snippet if available
if i < snippet_matches.len() {
let snippet = strip_tags(&snippet_matches[i][1]);
let snippet = snippet.trim();
if !snippet.is_empty() {
lines.push(format!(" {}", snippet));
}
}
}
Ok(lines.join("\n"))
}
async fn search_brave(&self, query: &str) -> anyhow::Result<String> {
let api_key = self
.brave_api_key
.as_ref()
.ok_or_else(|| anyhow::anyhow!("Brave API key not configured"))?;
let encoded_query = urlencoding::encode(query);
let search_url = format!(
"https://api.search.brave.com/res/v1/web/search?q={}&count={}",
encoded_query, self.max_results
);
let client = reqwest::Client::builder()
.timeout(Duration::from_secs(self.timeout_secs))
.build()?;
let response = client
.get(&search_url)
.header("Accept", "application/json")
.header("X-Subscription-Token", api_key)
.send()
.await?;
if !response.status().is_success() {
anyhow::bail!("Brave search failed with status: {}", response.status());
}
let json: serde_json::Value = response.json().await?;
self.parse_brave_results(&json, query)
}
fn parse_brave_results(&self, json: &serde_json::Value, query: &str) -> anyhow::Result<String> {
let results = json
.get("web")
.and_then(|w| w.get("results"))
.and_then(|r| r.as_array())
.ok_or_else(|| anyhow::anyhow!("Invalid Brave API response"))?;
if results.is_empty() {
return Ok(format!("No results found for: {}", query));
}
let mut lines = vec![format!("Search results for: {} (via Brave)", query)];
for (i, result) in results.iter().take(self.max_results).enumerate() {
let title = result
.get("title")
.and_then(|t| t.as_str())
.unwrap_or("No title");
let url = result.get("url").and_then(|u| u.as_str()).unwrap_or("");
let description = result
.get("description")
.and_then(|d| d.as_str())
.unwrap_or("");
lines.push(format!("{}. {}", i + 1, title));
lines.push(format!(" {}", url));
if !description.is_empty() {
lines.push(format!(" {}", description));
}
}
Ok(lines.join("\n"))
}
}
fn strip_tags(content: &str) -> String {
let re = Regex::new(r"<[^>]+>").unwrap();
re.replace_all(content, "").to_string()
}
#[async_trait]
impl Tool for WebSearchTool {
fn name(&self) -> &str {
"web_search_tool"
}
fn description(&self) -> &str {
"Search the web for information. Returns relevant search results with titles, URLs, and descriptions. Use this to find current information, news, or research topics."
}
fn parameters_schema(&self) -> serde_json::Value {
json!({
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The search query. Be specific for better results."
}
},
"required": ["query"]
})
}
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
let query = args
.get("query")
.and_then(|q| q.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: query"))?;
if query.trim().is_empty() {
anyhow::bail!("Search query cannot be empty");
}
tracing::info!("Searching web for: {}", query);
let result = match self.provider.to_lowercase().as_str() {
"duckduckgo" | "ddg" => self.search_duckduckgo(query).await?,
"brave" => self.search_brave(query).await?,
_ => anyhow::bail!("Unknown search provider: {}", self.provider),
};
Ok(ToolResult {
success: true,
output: result,
error: None,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tool_name() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
assert_eq!(tool.name(), "web_search_tool");
}
#[test]
fn test_tool_description() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
assert!(tool.description().contains("Search the web"));
}
#[test]
fn test_parameters_schema() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
let schema = tool.parameters_schema();
assert_eq!(schema["type"], "object");
assert!(schema["properties"]["query"].is_object());
}
#[test]
fn test_strip_tags() {
let html = "<b>Hello</b> <i>World</i>";
assert_eq!(strip_tags(html), "Hello World");
}
#[test]
fn test_parse_duckduckgo_results_empty() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
let result = tool
.parse_duckduckgo_results("<html>No results here</html>", "test")
.unwrap();
assert!(result.contains("No results found"));
}
#[test]
fn test_parse_duckduckgo_results_with_data() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
let html = r#"
<a class="result__a" href="https://example.com">Example Title</a>
<a class="result__snippet">This is a description</a>
"#;
let result = tool.parse_duckduckgo_results(html, "test").unwrap();
assert!(result.contains("Example Title"));
assert!(result.contains("https://example.com"));
}
#[tokio::test]
async fn test_execute_missing_query() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
let result = tool.execute(json!({})).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_execute_empty_query() {
let tool = WebSearchTool::new("duckduckgo".to_string(), None, 5, 15);
let result = tool.execute(json!({"query": ""})).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_execute_brave_without_api_key() {
let tool = WebSearchTool::new("brave".to_string(), None, 5, 15);
let result = tool.execute(json!({"query": "test"})).await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("API key"));
}
}