1

server-rs/crates/platform-llm/src/lib.rs

@@ -65,6 +65,7 @@ pub struct LlmTextRequest {
     pub model: Option<String>,
     pub messages: Vec<LlmMessage>,
     pub max_tokens: Option<u32>,
+    pub enable_web_search: bool,
 }
 
 // 上层在流式消费时拿到的是“累计文本 + 当前增量”，避免每层重新自己拼接。
@@ -122,8 +123,13 @@ struct ChatCompletionsRequestBody<'a> {
     stream: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     max_tokens: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    web_search_options: Option<ChatCompletionsWebSearchOptions>,
 }
 
+#[derive(Serialize)]
+struct ChatCompletionsWebSearchOptions {}
+
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct LlmRawFailureInputLog<'a> {
@@ -305,6 +311,7 @@ impl LlmTextRequest {
             model: None,
             messages,
             max_tokens: None,
+            enable_web_search: false,
         }
     }
 
@@ -325,6 +332,11 @@ impl LlmTextRequest {
         self
     }
 
+    pub fn with_web_search(mut self, enabled: bool) -> Self {
+        self.enable_web_search = enabled;
+        self
+    }
+
     fn validate(&self) -> Result<(), LlmError> {
         if self.messages.is_empty() {
             return Err(LlmError::InvalidRequest(
@@ -651,6 +663,9 @@ impl LlmClient {
             messages: request.messages.as_slice(),
             stream,
             max_tokens: request.max_tokens,
+            web_search_options: request
+                .enable_web_search
+                .then_some(ChatCompletionsWebSearchOptions {}),
         };
         let max_attempts = self.config.max_retries().saturating_add(1);
 
@@ -1228,6 +1243,47 @@ mod tests {
         assert_eq!(response.response_id.as_deref(), Some("resp_retry"));
     }
 
+    #[tokio::test]
+    async fn request_text_sends_web_search_options_when_enabled() {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("listener should bind");
+        let address = listener.local_addr().expect("listener should have addr");
+        let server_handle = thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("request should connect");
+            let request_text = read_request(&mut stream);
+            write_response(
+                &mut stream,
+                MockResponse {
+                    status_line: "200 OK",
+                    content_type: "application/json; charset=utf-8",
+                    body: r#"{"id":"resp_search","model":"test-model","choices":[{"message":{"content":"搜索成功"},"finish_reason":"stop"}]}"#.to_string(),
+                    extra_headers: Vec::new(),
+                },
+            );
+            request_text
+        });
+
+        let client = build_test_client(format!("http://{address}"), 0);
+        let response = client
+            .request_text(
+                LlmTextRequest::single_turn("系统", "用户")
+                    .with_web_search(true)
+                    .with_max_tokens(128),
+            )
+            .await
+            .expect("request_text should succeed");
+
+        let request_text = server_handle.join().expect("server thread should join");
+        let request_body = request_text
+            .split("\r\n\r\n")
+            .nth(1)
+            .expect("request body should exist");
+        let request_json: serde_json::Value =
+            serde_json::from_str(request_body).expect("request body should be json");
+
+        assert_eq!(response.content, "搜索成功");
+        assert_eq!(request_json["web_search_options"], serde_json::json!({}));
+    }
+
     #[tokio::test]
     async fn stream_text_accumulates_sse_response() {
         let server_url = spawn_mock_server(vec![MockResponse {
@@ -1344,7 +1400,7 @@ mod tests {
         format!("http://{address}")
     }
 
-    fn read_request(stream: &mut std::net::TcpStream) {
+    fn read_request(stream: &mut std::net::TcpStream) -> String {
         stream
             .set_read_timeout(Some(StdDuration::from_secs(1)))
             .expect("read timeout should be set");
@@ -1381,6 +1437,8 @@ mod tests {
                 Err(error) => panic!("mock server failed to read request: {error}"),
             }
         }
+
+        String::from_utf8_lossy(buffer.as_slice()).to_string()
     }
 
     fn write_response(stream: &mut std::net::TcpStream, response: MockResponse) {