implement Claude's web-search tool; remove DuckDuckGo

Author: alexylon

Cargo.lock

@@ -27,8 +27,6 @@ syntect = "5.2"
 # Utilities
 futures = "0.3"
 pathdiff = "0.2"
-urlencoding = "2.1"
-html-escape = "0.2"
 
 # Logging (optional but helpful)
 tracing = "0.1"

Cargo.toml

@@ -12,7 +12,7 @@ A blazingly fast, interactive AI coding assistant powered by Claude, implemented
 - **File Operations** - Read, write, list, and create files/directories (sandboxed to current directory)
 - **Ultra-Fast Editing** - Optional Morph Apply integration (10,500+ tokens/sec, 96-98% accuracy)
 - **Code Search** - Fast regex-based code search using `ripgrep` (optional)
-- **Web Search** - Real-time information via DuckDuckGo
+- **Web Search** - Real-time web information via Claude's native search tool
 - **Bash Execution** - Run tests and build commands safely (read-only, sandboxed)
 - **Secure** - All operations restricted to workspace, prevents directory traversal
 
@@ -97,7 +97,7 @@ Claude can automatically use these tools:
 
 **Code & Search:**
 - `search_code` - Fast regex-based code search (requires `ripgrep`)
-- `web_search` - Search the internet
+- `web_search` - Search the web for current information (Claude's server-side tool)
 - `execute_bash` - Run tests and build commands (read-only, sandboxed)
 
 ## Security

README.md

@@ -55,10 +55,24 @@ pub struct CreateMessageRequest {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Tool {
-    pub name: String,
-    pub description: String,
-    pub input_schema: serde_json::Value,
+#[serde(untagged)]
+pub enum Tool {
+    Regular {
+        name: String,
+        description: String,
+        input_schema: serde_json::Value,
+    },
+    WebSearch {
+        #[serde(rename = "type")]
+        tool_type: String,
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        max_uses: Option<u32>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        allowed_domains: Option<Vec<String>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        blocked_domains: Option<Vec<String>>,
+    },
 }
 
 #[derive(Debug, Deserialize)]
@@ -89,6 +103,27 @@ pub enum ContentBlock {
         name: String,
         input: serde_json::Value,
     },
+    #[serde(rename = "server_tool_use")]
+    ServerToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    #[serde(rename = "web_search_tool_result")]
+    WebSearchToolResult {
+        tool_use_id: String,
+        content: Vec<WebSearchResult>,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebSearchResult {
+    #[serde(rename = "type")]
+    pub result_type: String,
+    pub url: String,
+    pub title: String,
+    pub encrypted_content: String,
+    pub page_age: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -107,6 +142,17 @@ pub enum MessageContentBlock {
         tool_use_id: String,
         content: String,
     },
+    #[serde(rename = "server_tool_use")]
+    ServerToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    #[serde(rename = "web_search_tool_result")]
+    WebSearchToolResult {
+        tool_use_id: String,
+        content: Vec<WebSearchResult>,
+    },
 }
 
 impl MessageContentBlock {
@@ -118,10 +164,30 @@ impl MessageContentBlock {
                 name: name.clone(),
                 input: input.clone(),
             },
+            ContentBlock::ServerToolUse { id, name, input } => MessageContentBlock::ServerToolUse {
+                id: id.clone(),
+                name: name.clone(),
+                input: input.clone(),
+            },
+            ContentBlock::WebSearchToolResult { tool_use_id, content } => {
+                MessageContentBlock::WebSearchToolResult {
+                    tool_use_id: tool_use_id.clone(),
+                    content: content.clone(),
+                }
+            }
         }
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum _ContentDelta {
+    #[serde(rename = "text_delta")]
+    TextDelta { text: String },
+    #[serde(rename = "input_json_delta")]
+    InputJsonDelta { partial_json: String },
+}
+
 #[derive(Debug, Deserialize)]
 pub struct Usage {
     #[serde(rename = "input_tokens")]
@@ -160,12 +226,3 @@ pub enum _StreamEventType {
     #[serde(rename = "ping")]
     Ping,
 }
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(tag = "type")]
-pub enum _ContentDelta {
-    #[serde(rename = "text_delta")]
-    TextDelta { text: String },
-    #[serde(rename = "input_json_delta")]
-    InputJsonDelta { partial_json: String },
-}

src/api/types.rs

@@ -23,9 +23,6 @@ pub enum SofosError {
     #[error("File not found: {0}")]
     FileNotFound(String),
 
-    #[error("Search error: {0}")]
-    Search(String),
-
     #[error("Configuration error: {0}")]
     Config(String),
 

src/error.rs

@@ -181,6 +181,17 @@ impl Repl {
                 ContentBlock::ToolUse { id, name, input } => {
                     tool_uses.push((id.clone(), name.clone(), input.clone()));
                 }
+                ContentBlock::ServerToolUse { name, input, .. } => {
+                    // Server-side tools (like web_search) are executed by Claude API
+                    if std::env::var("SOFOS_DEBUG").is_ok() {
+                        eprintln!("Server tool use: {} with input: {:?}", name, input);
+                    }
+                }
+                ContentBlock::WebSearchToolResult { content, .. } => {
+                    if !content.is_empty() {
+                        text_output.push(format!("\n[Web search returned {} results]", content.len()));
+                    }
+                }
             }
         }
 
@@ -419,6 +430,12 @@ impl Repl {
                         ContentBlock::ToolUse { name, .. } => {
                             eprintln!("  Block {}: ToolUse({})", i, name)
                         }
+                        ContentBlock::ServerToolUse { name, .. } => {
+                            eprintln!("  Block {}: ServerToolUse({})", i, name)
+                        }
+                        ContentBlock::WebSearchToolResult { content, .. } => {
+                            eprintln!("  Block {}: WebSearchToolResult({} results)", i, content.len())
+                        }
                     }
                 }
             }

src/repl.rs

@@ -1,15 +1,13 @@
 pub mod bashexec;
 pub mod codesearch;
 pub mod filesystem;
-pub mod search;
 pub mod types;
 
 use crate::api::MorphClient;
 use crate::error::{Result, SofosError};
 use bashexec::BashExecutor;
 use codesearch::CodeSearchTool;
 use filesystem::FileSystemTool;
-use search::WebSearchTool;
 use serde_json::Value;
 use std::io::{self, Write};
 
@@ -29,7 +27,6 @@ fn confirm_action(prompt: &str) -> Result<bool> {
 /// ToolExecutor handles execution of tool calls from Claude
 pub struct ToolExecutor {
     fs_tool: FileSystemTool,
-    search_tool: WebSearchTool,
     code_search_tool: Option<CodeSearchTool>,
     bash_executor: BashExecutor,
     morph_client: Option<MorphClient>,
@@ -47,7 +44,6 @@ impl ToolExecutor {
 
         Ok(Self {
             fs_tool: FileSystemTool::new(workspace.clone())?,
-            search_tool: WebSearchTool::new()?,
             code_search_tool,
             bash_executor: BashExecutor::new(workspace)?,
             morph_client,
@@ -114,34 +110,6 @@ impl ToolExecutor {
                 self.fs_tool.create_directory(path)?;
                 Ok(format!("Successfully created directory '{}'", path))
             }
-            "web_search" => {
-                let query = input["query"].as_str().ok_or_else(|| {
-                    SofosError::ToolExecution("Missing 'query' parameter".to_string())
-                })?;
-                let max_results = input["max_results"].as_u64().unwrap_or(5) as usize;
-
-                let results = self.search_tool.search(query, max_results).await?;
-
-                if results.is_empty() {
-                    Ok(format!("No search results found for '{}'", query))
-                } else {
-                    let formatted = results
-                        .iter()
-                        .enumerate()
-                        .map(|(i, r)| {
-                            format!(
-                                "{}. {}\n   URL: {}\n   {}",
-                                i + 1,
-                                r.title,
-                                r.url,
-                                r.snippet
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join("\n\n");
-                    Ok(format!("Search results for '{}':\n\n{}", query, formatted))
-                }
-            }
             "search_code" => {
                 let code_search = self.code_search_tool.as_ref()
                     .ok_or_else(|| SofosError::ToolExecution(
@@ -258,6 +226,7 @@ impl ToolExecutor {
                 let result = self.bash_executor.execute(command)?;
                 Ok(result)
             }
+            // web_search is now handled server-side by Claude API, not by ToolExecutor
             _ => Err(SofosError::ToolExecution(format!(
                 "Unknown tool: {}",
                 tool_name