RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(agent): add Querit Contents tool (#18156)
EthanZhang1d8b9c74522c
diff --git a/agent/tools/querit.py b/agent/tools/querit.pyindex 6725342a94..51822e7965 100644--- a/agent/tools/querit.py+++ b/agent/tools/querit.py@@ -20,6 +20,7 @@ import reimport timefrom abc import ABCfrom typing import Any+from urllib.parse import urlparseimport requests@@ -28,8 +29,10 @@ from common.connection_utils import timeoutfrom common.http_client import DEFAULT_TIMEOUTQUERIT_SEARCH_URL = "https://api.querit.ai/v1/search"+QUERIT_CONTENTS_URL = "https://api.querit.ai/v1/contents"QUERIT_MAX_ATTEMPTS = 3QUERIT_RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}+QUERIT_CONTENT_FORMATS = {"text", "markdown", "html"}TIME_RANGE_PATTERN = re.compile(r"^([dwmy][1-9][0-9]*|\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2})$")logger = logging.getLogger(__name__)@@ -192,35 +195,7 @@ class QueritSearch(ToolBase, ABC):return self._fail(_safe_error_message(error, api_key))def _search(self, payload: dict[str, Any], api_key: str) -> Any:- headers = {- "Accept": "application/json",- "Authorization": f"Bearer {api_key}",- "Content-Type": "application/json",- }- for attempt in range(QUERIT_MAX_ATTEMPTS):- if self.check_if_canceled("QueritSearch processing"):- raise _QueritCanceled- try:- response = requests.post(- QUERIT_SEARCH_URL,- headers=headers,- json=payload,- timeout=DEFAULT_TIMEOUT,- )- if response.status_code in QUERIT_RETRYABLE_STATUS_CODES and attempt + 1 < QUERIT_MAX_ATTEMPTS:- self._wait_before_retry()- continue- response.raise_for_status()- return response.json()- except requests.JSONDecodeError:- raise- except requests.HTTPError:- raise- except requests.RequestException:- if attempt + 1 >= QUERIT_MAX_ATTEMPTS:- raise- self._wait_before_retry()- raise RuntimeError("Querit request failed after three attempts.")+ return _post_querit(self, QUERIT_SEARCH_URL, payload, api_key, "QueritSearch")def _wait_before_retry(self) -> None:if self.check_if_canceled("QueritSearch processing"):@@ -236,6 +211,96 @@ class QueritSearch(ToolBase, ABC):return "Searching Querit for `{}`.".format(self.get_input().get("query", "-_-!"))+class QueritContentsParam(ToolParamBase):+ def __init__(self):+ self.meta: ToolMeta = {+ "name": "querit_contents",+ "description": "Crawl one or more web pages with Querit and return their contents.",+ "parameters": {+ "urls": {+ "type": "array",+ "description": "The absolute HTTP or HTTPS URLs to crawl. Supports 1 to 10 URLs.",+ "default": [],+ "items": {"type": "string"},+ "required": True,+ },+ "format": {+ "type": "string",+ "description": "Content format: text, markdown, or html. Defaults to markdown.",+ "enum": ["text", "markdown", "html"],+ "default": "markdown",+ "required": False,+ },+ "crawl_timeout": {+ "type": "integer",+ "description": "Per-page crawl timeout in seconds. Must be between 1 and 60.",+ "default": 10,+ "required": False,+ },+ "extras_meta": {+ "type": "boolean",+ "description": "Whether to include page metadata in each result.",+ "default": False,+ "required": False,+ },+ },+ }+ super().__init__()+ self.api_key = ""++ def check(self):+ self.urls = _normalize_contents_urls(self.urls)+ _validate_contents_inputs(self.urls, self.format, self.crawl_timeout, self.extras_meta)++ def get_input_form(self) -> dict[str, dict]:+ return {"urls": {"name": "URLs", "type": "line"}}+++class QueritContents(ToolBase, ABC):+ component_name = "QueritContents"++ @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", "70")))+ def _invoke(self, **kwargs):+ if self.check_if_canceled("QueritContents processing"):+ return++ values = {name: kwargs[name] if name in kwargs else getattr(self._param, name) for name in ("urls", "format", "crawl_timeout", "extras_meta")}+ values["urls"] = _normalize_contents_urls(values["urls"])++ node_api_key = (self._param.api_key or "").strip()+ api_key = node_api_key or (os.environ.get("QUERIT_API_KEY") or "").strip()+ if not api_key:+ return self._fail("Querit API key is required. Configure api_key or set QUERIT_API_KEY.")++ try:+ _validate_contents_inputs(**values)+ response_data = self._request(_build_contents_payload(**values), api_key)+ _validate_contents_response(response_data)+ self.set_output("json", response_data)+ return self.output("json")+ except _QueritCanceled:+ return+ except (requests.RequestException, RuntimeError, TypeError, ValueError) as error:+ return self._fail(_safe_error_message(error, api_key))++ def _request(self, payload: dict[str, Any], api_key: str) -> Any:+ request_timeout = max(DEFAULT_TIMEOUT, payload["crawlTimeout"] + 5)+ return _post_querit(self, QUERIT_CONTENTS_URL, payload, api_key, "QueritContents", request_timeout)++ def _wait_before_retry(self) -> None:+ if self.check_if_canceled("QueritContents processing"):+ raise _QueritCanceled+ time.sleep(self._param.delay_after_error)++ def _fail(self, message: str) -> str:+ self.set_output("_ERROR", message)+ logger.error("Querit contents failed: %s", message)+ return f"Querit contents error: {message}"++ def thoughts(self) -> str:+ return "Reading web page contents with Querit."++def _build_payload(query: str, **values: Any) -> dict[str, Any]:payload: dict[str, Any] = {"query": query,@@ -262,6 +327,72 @@ def _build_payload(query: str, **values: Any) -> dict[str, Any]:return payload+def _post_querit(tool: Any, endpoint: str, payload: dict[str, Any], api_key: str, operation: str, request_timeout: float = DEFAULT_TIMEOUT) -> Any:+ headers = {+ "Accept": "application/json",+ "Authorization": f"Bearer {api_key}",+ "Content-Type": "application/json",+ }+ for attempt in range(QUERIT_MAX_ATTEMPTS):+ if tool.check_if_canceled(f"{operation} processing"):+ raise _QueritCanceled+ try:+ response = requests.post(endpoint, headers=headers, json=payload, timeout=request_timeout)+ if response.status_code in QUERIT_RETRYABLE_STATUS_CODES and attempt + 1 < QUERIT_MAX_ATTEMPTS:+ tool._wait_before_retry()+ continue+ response.raise_for_status()+ return response.json()+ except requests.JSONDecodeError:+ raise+ except requests.HTTPError:+ raise+ except requests.RequestException:+ if attempt + 1 >= QUERIT_MAX_ATTEMPTS:+ raise+ tool._wait_before_retry()+ raise RuntimeError("Querit request failed after three attempts.")+++def _build_contents_payload(urls: list[str], format: str, crawl_timeout: int, extras_meta: bool) -> dict[str, Any]:+ return {+ "urls": urls,+ "format": format,+ "crawlTimeout": crawl_timeout,+ "extrasMeta": extras_meta,+ }+++def _normalize_contents_urls(urls: Any) -> Any:+ if isinstance(urls, str):+ return [url.strip() for url in urls.split(",") if url.strip()]+ return urls+++def _validate_contents_inputs(urls: Any, format: Any, crawl_timeout: Any, extras_meta: Any) -> None:+ if not isinstance(urls, list) or not 1 <= len(urls) <= 10 or any(not isinstance(url, str) or not url.strip() for url in urls):+ raise ValueError("Querit urls must contain between 1 and 10 non-empty strings.")+ for url in urls:+ parsed = urlparse(url)+ if parsed.scheme not in {"http", "https"} or not parsed.netloc:+ raise ValueError("Querit urls must be absolute HTTP or HTTPS URLs.")+ if format not in QUERIT_CONTENT_FORMATS:+ raise ValueError("Querit format must be text, markdown, or html.")+ if type(crawl_timeout) is not int or not 1 <= crawl_timeout <= 60:+ raise ValueError("Querit crawl_timeout must be an integer from 1 to 60.")+ if type(extras_meta) is not bool:+ raise ValueError("Querit extras_meta must be a boolean.")+++def _validate_contents_response(response_data: Any) -> None:+ if not isinstance(response_data, dict):+ raise TypeError("Querit API response must be a JSON object.")+ if "results" in response_data and not isinstance(response_data["results"], list):+ raise TypeError("Querit API response field results must be an array.")+ if "statuses" in response_data and not isinstance(response_data["statuses"], list):+ raise TypeError("Querit API response field statuses must be an array.")++def _validate_search_inputs(count: Any,chunks_per_doc: Any,diff --git a/internal/agent/component/tool_component.go b/internal/agent/component/tool_component.goindex 2eaca204b5..9d7ac01859 100644--- a/internal/agent/component/tool_component.go+++ b/internal/agent/component/tool_component.go@@ -134,6 +134,7 @@ var toolComponentRegistrations = []struct {{componentName: "GoogleScholar", toolName: "google_scholar"},{componentName: "KeenableSearch", toolName: "keenable"},{componentName: "PubMed", toolName: "pubmed"},+ {componentName: "QueritContents", toolName: "querit_contents"},{componentName: "QueritSearch", toolName: "querit_search"},{componentName: "SearXNG", toolName: "searxng"},{componentName: "TavilySearch", toolName: "tavily"},diff --git a/internal/agent/component/tool_component_test.go b/internal/agent/component/tool_component_test.goindex 64decfa181..13ffaf5c01 100644--- a/internal/agent/component/tool_component_test.go+++ b/internal/agent/component/tool_component_test.go@@ -193,6 +193,13 @@ func TestToolBackedComponentRegisteredFactories(t *testing.T) {outputKey: "success",inputKey: "to_email",},+ {+ name: "QueritContents",+ toolName: "QueritContents",+ params: map[string]any{"api_key": "stored-key", "format": "markdown", "crawl_timeout": float64(10), "extras_meta": true, "outputs": map[string]any{"json": map[string]any{}}},+ outputKey: "json",+ inputKey: "urls",+ },{name: "QueritSearch",toolName: "QueritSearch",@@ -283,7 +290,7 @@ func TestToolBackedComponentWenCaiInvoke(t *testing.T) {}func TestToolBackedComponentRegisteredBuildWorkflow(t *testing.T) {- for _, componentName := range []string{"ArXiv", "BGPT", "DuckDuckGo", "Email", "Google", "GoogleScholar", "KeenableSearch", "PubMed", "QueritSearch", "SearXNG", "WenCai", "TavilyExtract", "TavilySearch", "Wikipedia", "YahooFinance"} {+ for _, componentName := range []string{"ArXiv", "BGPT", "DuckDuckGo", "Email", "Google", "GoogleScholar", "KeenableSearch", "PubMed", "QueritContents", "QueritSearch", "SearXNG", "WenCai", "TavilyExtract", "TavilySearch", "Wikipedia", "YahooFinance"} {t.Run(componentName, func(t *testing.T) {c := &canvas.Canvas{Components: map[string]canvas.CanvasComponent{diff --git a/internal/agent/tool/querit.go b/internal/agent/tool/querit.goindex 5555c97f6e..a94d40a0ca 100644--- a/internal/agent/tool/querit.go+++ b/internal/agent/tool/querit.go@@ -248,44 +248,58 @@ func (q *QueritTool) InvokableRun(ctx context.Context, argsJSON string, _ ...tooif err != nil {return queritErrorJSON(fmt.Errorf("encode request: %w", err), apiKey), nil}+ raw, requestErr := doQueritRequest(ctx, q.helper, q.retryWait, queritEndpoint, body, apiKey)+ if requestErr != nil {+ return queritErrorJSON(requestErr, apiKey), nil+ }+ if _, err := decodeQueritResponse(raw); err != nil {+ return queritErrorJSON(err, apiKey), nil+ }+ return string(raw), nil+}++func doQueritRequest(+ ctx context.Context,+ helper *HTTPHelper,+ retryWait func(context.Context, int) bool,+ endpoint string,+ body []byte,+ apiKey string,+) ([]byte, error) {for attempt := 1; attempt <= queritMaxAttempts; attempt++ {- resp, requestErr := q.helper.Do(+ resp, err := helper.Do(ctx,http.MethodPost,- queritEndpoint,+ endpoint,string(body),"application/json",map[string]string{"Authorization": "Bearer " + apiKey},)- if requestErr != nil {- return queritErrorJSON(fmt.Errorf("request failed: %w", requestErr), apiKey), nil+ if err != nil {+ return nil, fmt.Errorf("request failed: %w", err)}if resp.StatusCode == http.StatusTooManyRequests {_, _ = io.Copy(io.Discard, resp.Body)_ = resp.Body.Close()- if attempt == queritMaxAttempts || !q.retryWait(ctx, attempt) {- return queritErrorJSON(fmt.Errorf("upstream returned %d after %d attempts", resp.StatusCode, attempt), apiKey), nil+ if attempt == queritMaxAttempts || !retryWait(ctx, attempt) {+ return nil, fmt.Errorf("upstream returned %d after %d attempts", resp.StatusCode, attempt)}continue}if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {_, _ = io.Copy(io.Discard, resp.Body)_ = resp.Body.Close()- return queritErrorJSON(fmt.Errorf("upstream returned %d", resp.StatusCode), apiKey), nil+ return nil, fmt.Errorf("upstream returned %d", resp.StatusCode)}raw, readErr := io.ReadAll(resp.Body)_ = resp.Body.Close()if readErr != nil {- return queritErrorJSON(fmt.Errorf("read response: %w", readErr), apiKey), nil+ return nil, fmt.Errorf("read response: %w", readErr)}- if _, err := decodeQueritResponse(raw); err != nil {- return queritErrorJSON(err, apiKey), nil- }- return string(raw), nil+ return raw, nil}-- return queritErrorJSON(fmt.Errorf("request exhausted retries"), apiKey), nil+ return nil, fmt.Errorf("request exhausted retries")}func mergeQueritParams(defaults, runtimeParams queritParams, provided map[string]json.RawMessage) queritParams {@@ -360,21 +374,9 @@ func buildQueritRequest(params queritParams) queritRequest {}func decodeQueritResponse(raw []byte) (map[string]any, error) {- var decoded any- decoder := json.NewDecoder(strings.NewReader(string(raw)))- decoder.UseNumber()- if err := decoder.Decode(&decoded); err != nil {- return nil, fmt.Errorf("decode response: %w", err)- }- if err := decoder.Decode(&struct{}{}); err != io.EOF {- if err == nil {- return nil, fmt.Errorf("decode response: expected exactly one JSON value")- }- return nil, fmt.Errorf("decode response: trailing content: %w", err)- }- response, ok := decoded.(map[string]any)- if !ok || response == nil {- return nil, fmt.Errorf("decode response: expected a JSON object")+ response, err := decodeQueritJSONObject(raw)+ if err != nil {+ return nil, err}resultsValue, exists := response["results"]if !exists {@@ -394,6 +396,26 @@ func decodeQueritResponse(raw []byte) (map[string]any, error) {return response, nil}+func decodeQueritJSONObject(raw []byte) (map[string]any, error) {+ var decoded any+ decoder := json.NewDecoder(strings.NewReader(string(raw)))+ decoder.UseNumber()+ if err := decoder.Decode(&decoded); err != nil {+ return nil, fmt.Errorf("decode response: %w", err)+ }+ if err := decoder.Decode(&struct{}{}); err != io.EOF {+ if err == nil {+ return nil, fmt.Errorf("decode response: expected exactly one JSON value")+ }+ return nil, fmt.Errorf("decode response: trailing content: %w", err)+ }+ response, ok := decoded.(map[string]any)+ if !ok || response == nil {+ return nil, fmt.Errorf("decode response: expected a JSON object")+ }+ return response, nil+}+func waitForQueritRetry(ctx context.Context, attempt int) bool {delay := 200 * time.Millisecondfor current := 1; current < attempt; current++ {@@ -588,9 +610,13 @@ func queritStringSlice(value any) ([]string, bool) {}func queritErrorJSON(err error, apiKeys ...string) string {- message := "querit_search: unknown error"+ return queritToolErrorJSON(queritToolName, err, apiKeys...)+}++func queritToolErrorJSON(toolName string, err error, apiKeys ...string) string {+ message := toolName + ": unknown error"if err != nil {- message = "querit_search: " + err.Error()+ message = toolName + ": " + err.Error()}for _, apiKey := range apiKeys {if apiKey = strings.TrimSpace(apiKey); apiKey != "" {@@ -599,7 +625,7 @@ func queritErrorJSON(err error, apiKeys ...string) string {}raw, marshalErr := json.Marshal(map[string]any{"_ERROR": message})if marshalErr != nil {- return `{"_ERROR":"querit_search: marshal error"}`+ return fmt.Sprintf(`{"_ERROR":%q}`, toolName+": marshal error")}return string(raw)}diff --git a/internal/agent/tool/querit_contents.go b/internal/agent/tool/querit_contents.gonew file mode 100644index 0000000000..20ed212dff--- /dev/null+++ b/internal/agent/tool/querit_contents.go@@ -0,0 +1,271 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package tool++import (+ "context"+ "encoding/json"+ "fmt"+ "net/url"+ "strings"+ "time"++ "github.com/cloudwego/eino/components/tool"+ "github.com/cloudwego/eino/schema"+)++const (+ queritContentsToolName = "querit_contents"+ queritContentsEndpoint = "https://api.querit.ai/v1/contents"+)++type queritContentsParams struct {+ APIKey string `json:"api_key"`+ URLs any `json:"urls"`+ Format string `json:"format"`+ CrawlTimeout int `json:"crawl_timeout"`+ ExtrasMeta bool `json:"extras_meta"`+}++type queritContentsRequest struct {+ URLs []string `json:"urls"`+ Format string `json:"format"`+ CrawlTimeout int `json:"crawlTimeout"`+ ExtrasMeta bool `json:"extrasMeta"`+}++// QueritContentsTool crawls public web pages through the Querit Contents API.+type QueritContentsTool struct {+ helper *HTTPHelper+ envKey func() string+ defaults queritContentsParams+ retryWait func(context.Context, int) bool+}++var _ ToolComponent = (*QueritContentsTool)(nil)++func NewQueritContentsTool() *QueritContentsTool {+ return newQueritContentsTool(nil, nil, queritContentsParams{}, nil)+}++func NewQueritContentsToolWith(helper *HTTPHelper) *QueritContentsTool {+ return newQueritContentsTool(helper, nil, queritContentsParams{}, nil)+}++func NewQueritContentsToolWithEnvKey(helper *HTTPHelper, envKey func() string) *QueritContentsTool {+ return newQueritContentsTool(helper, envKey, queritContentsParams{}, nil)+}++func newQueritContentsTool(+ helper *HTTPHelper,+ envKey func() string,+ defaults queritContentsParams,+ retryWait func(context.Context, int) bool,+) *QueritContentsTool {+ if helper == nil {+ helper = NewHTTPHelper()+ helper.client.Timeout = 65 * time.Second+ }+ if envKey == nil {+ envKey = defaultQueritEnvKey+ }+ if defaults.Format == "" {+ defaults.Format = "markdown"+ }+ if defaults.CrawlTimeout == 0 {+ defaults.CrawlTimeout = 10+ }+ if retryWait == nil {+ retryWait = waitForQueritRetry+ }+ return &QueritContentsTool{helper: helper, envKey: envKey, defaults: defaults, retryWait: retryWait}+}++func (q *QueritContentsTool) Info(_ context.Context) (*schema.ToolInfo, error) {+ return &schema.ToolInfo{+ Name: queritContentsToolName,+ Desc: "Crawl one or more web pages with Querit and return their contents.",+ ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{+ "urls": {+ Type: schema.Array,+ ElemInfo: &schema.ParameterInfo{Type: schema.String},+ Desc: "One to ten absolute HTTP or HTTPS URLs to crawl.",+ Required: true,+ },+ "format": {+ Type: schema.String,+ Desc: `Content format: "text", "markdown" (default), or "html".`,+ Required: false,+ },+ "crawl_timeout": {+ Type: schema.Integer,+ Desc: "Per-page crawl timeout in seconds. Defaults to 10 and must be between 1 and 60.",+ Required: false,+ },+ "extras_meta": {+ Type: schema.Boolean,+ Desc: "Whether to include page metadata in each result.",+ Required: false,+ },+ }),+ }, nil+}++func (q *QueritContentsTool) InvokableRun(ctx context.Context, argsJSON string, _ ...tool.Option) (string, error) {+ provided := make(map[string]json.RawMessage)+ if err := json.Unmarshal([]byte(argsJSON), &provided); err != nil {+ return queritContentsErrorJSON(fmt.Errorf("parse arguments: %w", err)), nil+ }+ var runtimeParams queritContentsParams+ if err := json.Unmarshal([]byte(argsJSON), &runtimeParams); err != nil {+ return queritContentsErrorJSON(fmt.Errorf("parse arguments: %w", err)), nil+ }+ params := mergeQueritContentsParams(q.defaults, runtimeParams, provided)+ urls := normalizeQueritContentURLs(params.URLs)+ if err := validateQueritContentsParams(params, urls); err != nil {+ return queritContentsErrorJSON(err, params.APIKey), nil+ }++ apiKey := strings.TrimSpace(params.APIKey)+ if apiKey == "" {+ apiKey = strings.TrimSpace(q.envKey())+ }+ if apiKey == "" {+ return queritContentsErrorJSON(fmt.Errorf("api_key is required (or set QUERIT_API_KEY)")), nil+ }++ body, err := json.Marshal(queritContentsRequest{+ URLs: urls,+ Format: params.Format,+ CrawlTimeout: params.CrawlTimeout,+ ExtrasMeta: params.ExtrasMeta,+ })+ if err != nil {+ return queritContentsErrorJSON(fmt.Errorf("encode request: %w", err), apiKey), nil+ }+ raw, requestErr := doQueritRequest(ctx, q.helper, q.retryWait, queritContentsEndpoint, body, apiKey)+ if requestErr != nil {+ return queritContentsErrorJSON(requestErr, apiKey), nil+ }+ if _, err := decodeQueritContentsResponse(raw); err != nil {+ return queritContentsErrorJSON(err, apiKey), nil+ }+ return string(raw), nil+}++func mergeQueritContentsParams(+ defaults queritContentsParams,+ runtimeParams queritContentsParams,+ provided map[string]json.RawMessage,+) queritContentsParams {+ merged := defaults+ if _, ok := provided["urls"]; ok {+ merged.URLs = runtimeParams.URLs+ }+ if _, ok := provided["format"]; ok {+ merged.Format = runtimeParams.Format+ }+ if _, ok := provided["crawl_timeout"]; ok {+ merged.CrawlTimeout = runtimeParams.CrawlTimeout+ }+ if _, ok := provided["extras_meta"]; ok {+ merged.ExtrasMeta = runtimeParams.ExtrasMeta+ }+ return merged+}++func validateQueritContentsParams(params queritContentsParams, urls []string) error {+ if len(urls) < 1 || len(urls) > 10 {+ return fmt.Errorf("urls must contain between 1 and 10 values")+ }+ for _, rawURL := range urls {+ parsed, err := url.ParseRequestURI(rawURL)+ if err != nil || (parsed.Scheme != "http" && parsed.Scheme != "https") || parsed.Host == "" {+ return fmt.Errorf("urls must be absolute HTTP or HTTPS URLs")+ }+ }+ if params.Format != "text" && params.Format != "markdown" && params.Format != "html" {+ return fmt.Errorf("format must be text, markdown, or html")+ }+ if params.CrawlTimeout < 1 || params.CrawlTimeout > 60 {+ return fmt.Errorf("crawl_timeout must be between 1 and 60")+ }+ return nil+}++func normalizeQueritContentURLs(raw any) []string {+ switch value := raw.(type) {+ case string:+ return compactStrings(strings.Split(value, ","))+ case []string:+ return compactStrings(value)+ case []any:+ urls := make([]string, 0, len(value))+ for _, item := range value {+ text, ok := item.(string)+ if !ok {+ return nil+ }+ urls = append(urls, text)+ }+ return compactStrings(urls)+ default:+ return nil+ }+}++func decodeQueritContentsResponse(raw []byte) (map[string]any, error) {+ response, err := decodeQueritJSONObject(raw)+ if err != nil {+ return nil, err+ }+ for _, field := range []string{"results", "statuses"} {+ if value, exists := response[field]; exists {+ if _, ok := value.([]any); !ok {+ return nil, fmt.Errorf("decode response: %s must be a JSON array", field)+ }+ }+ }+ return response, nil+}++func (q *QueritContentsTool) ComponentSpec() ComponentSpec {+ return ComponentSpec{+ PreserveJSONNumbers: true,+ Inputs: map[string]string{+ "api_key": "Querit API key. Uses QUERIT_API_KEY when empty.",+ "urls": "One to ten absolute HTTP or HTTPS URLs to crawl.",+ "format": `Content format: "text", "markdown", or "html".`,+ "crawl_timeout": "Per-page crawl timeout in seconds.",+ "extras_meta": "Whether to include page metadata.",+ },+ Outputs: map[string]string{+ "json": "Complete raw Querit Contents JSON response.",+ },+ InputForm: map[string]any{+ "urls": map[string]any{"name": "URLs", "type": "line"},+ },+ }+}++func (q *QueritContentsTool) BuildComponentOutputs(response map[string]any) map[string]any {+ return map[string]any{"json": response}+}++func queritContentsErrorJSON(err error, apiKeys ...string) string {+ return queritToolErrorJSON(queritContentsToolName, err, apiKeys...)+}diff --git a/internal/agent/tool/querit_contents_test.go b/internal/agent/tool/querit_contents_test.gonew file mode 100644index 0000000000..76645d57da--- /dev/null+++ b/internal/agent/tool/querit_contents_test.go@@ -0,0 +1,188 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package tool++import (+ "context"+ "encoding/json"+ "errors"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"+)++func TestQueritContentsBuildsRequestAndPreservesResponse(t *testing.T) {+ var gotMethod, gotPath, gotAuthorization string+ var gotBody map[string]any+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ gotMethod = request.Method+ gotPath = request.URL.Path+ gotAuthorization = request.Header.Get("Authorization")+ _ = json.NewDecoder(request.Body).Decode(&gotBody)+ writer.Header().Set("Content-Type", "application/json")+ _, _ = writer.Write([]byte(`{"error_code":0,"search_id":"crawl-1","results":[{"id":"1","url":"https://example.com","content":"# Example"}],"statuses":[{"id":"1","status":"success"}],"searchTime":1}`))+ }))+ defer server.Close()++ helper := NewHTTPHelper().WithClient(&http.Client{Transport: rewriteQueritHostTransport(server.URL)})+ contents := newQueritContentsTool(helper, func() string { return "" }, queritContentsParams{APIKey: "key-test"}, nil)+ out, err := contents.InvokableRun(context.Background(), `{"urls":["https://example.com"],"format":"html","crawl_timeout":20,"extras_meta":true}`)+ if err != nil {+ t.Fatalf("InvokableRun: %v", err)+ }+ if gotMethod != http.MethodPost || gotPath != "/v1/contents" {+ t.Fatalf("request = %s %s, want POST /v1/contents", gotMethod, gotPath)+ }+ if gotAuthorization != "Bearer key-test" {+ t.Fatalf("Authorization = %q", gotAuthorization)+ }+ if gotBody["format"] != "html" || gotBody["crawlTimeout"] != float64(20) || gotBody["extrasMeta"] != true {+ t.Fatalf("request body = %#v", gotBody)+ }+ urls, ok := gotBody["urls"].([]any)+ if !ok || len(urls) != 1 || urls[0] != "https://example.com" {+ t.Fatalf("urls = %#v", gotBody["urls"])+ }+ if !strings.Contains(out, `"search_id":"crawl-1"`) || !strings.Contains(out, `"statuses"`) {+ t.Fatalf("complete response was not retained: %s", out)+ }+}++func TestQueritContentsMergesDefaultsAndExplicitFalse(t *testing.T) {+ var gotBody map[string]any+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {+ _ = json.NewDecoder(request.Body).Decode(&gotBody)+ _, _ = writer.Write([]byte(`{"results":[],"statuses":[]}`))+ }))+ defer server.Close()++ helper := NewHTTPHelper().WithClient(&http.Client{Transport: rewriteQueritHostTransport(server.URL)})+ contents := newQueritContentsTool(helper, func() string { return "" }, queritContentsParams{+ APIKey: "stored-key",+ URLs: []string{"https://stored.example"},+ Format: "text",+ CrawlTimeout: 30,+ ExtrasMeta: true,+ }, nil)+ _, err := contents.InvokableRun(context.Background(), `{"urls":"https://runtime.example","extras_meta":false}`)+ if err != nil {+ t.Fatalf("InvokableRun: %v", err)+ }+ if gotBody["format"] != "text" || gotBody["crawlTimeout"] != float64(30) || gotBody["extrasMeta"] != false {+ t.Fatalf("merged defaults = %#v", gotBody)+ }+ if gotBody["urls"].([]any)[0] != "https://runtime.example" {+ t.Fatalf("runtime urls = %#v", gotBody["urls"])+ }+}++func TestQueritContentsValidatesInputsAndAPIKey(t *testing.T) {+ tests := []struct {+ name string+ args string+ want string+ }{+ {name: "missing urls", args: `{}`, want: "urls must contain"},+ {name: "too many urls", args: `{"urls":["https://1.example","https://2.example","https://3.example","https://4.example","https://5.example","https://6.example","https://7.example","https://8.example","https://9.example","https://10.example","https://11.example"]}`, want: "between 1 and 10"},+ {name: "relative url", args: `{"urls":["example.com"]}`, want: "absolute HTTP or HTTPS"},+ {name: "unsupported scheme", args: `{"urls":["file:///tmp/page"]}`, want: "absolute HTTP or HTTPS"},+ {name: "bad format", args: `{"urls":["https://example.com"],"format":"xml"}`, want: "format must be"},+ {name: "bad timeout", args: `{"urls":["https://example.com"],"crawl_timeout":61}`, want: "between 1 and 60"},+ }+ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ contents := NewQueritContentsToolWithEnvKey(NewHTTPHelper(), func() string { return "key-test" })+ out, err := contents.InvokableRun(context.Background(), test.args)+ if err != nil || !strings.Contains(out, "_ERROR") || !strings.Contains(out, test.want) {+ t.Fatalf("result = %s, err = %v", out, err)+ }+ })+ }++ contents := NewQueritContentsToolWithEnvKey(NewHTTPHelper(), func() string { return "" })+ out, err := contents.InvokableRun(context.Background(), `{"urls":["https://example.com"]}`)+ if err != nil || !strings.Contains(out, "api_key is required") {+ t.Fatalf("missing key result = %s, err = %v", out, err)+ }+}++func TestQueritContentsRejectsMalformedResponses(t *testing.T) {+ for _, test := range []struct {+ name string+ body string+ want string+ }{+ {name: "top-level array", body: `[]`, want: "JSON object"},+ {name: "results object", body: `{"results":{}}`, want: "results must be a JSON array"},+ {name: "statuses object", body: `{"results":[],"statuses":{}}`, want: "statuses must be a JSON array"},+ {name: "trailing content", body: `{"results":[]} trailing`, want: "trailing content"},+ } {+ t.Run(test.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {+ _, _ = writer.Write([]byte(test.body))+ }))+ defer server.Close()+ helper := NewHTTPHelper().WithClient(&http.Client{Transport: rewriteQueritHostTransport(server.URL)})+ contents := NewQueritContentsToolWithEnvKey(helper, func() string { return "key-test" })+ out, err := contents.InvokableRun(context.Background(), `{"urls":["https://example.com"]}`)+ if err != nil || !strings.Contains(out, test.want) {+ t.Fatalf("result = %s, err = %v", out, err)+ }+ })+ }+}++func TestQueritContentsRedactsAPIKey(t *testing.T) {+ const secret = "secret-contents-key"+ helper := NewHTTPHelper().WithClient(&http.Client{Transport: roundTripperErrorFunc(func(*http.Request) error {+ return errors.New("failed with " + secret)+ })})+ contents := NewQueritContentsToolWithEnvKey(helper, func() string { return secret })+ out, err := contents.InvokableRun(context.Background(), `{"urls":["https://example.com"]}`)+ if err != nil || strings.Contains(out, secret) || !strings.Contains(out, "[REDACTED]") {+ t.Fatalf("result = %s, err = %v", out, err)+ }+}++func TestQueritContentsInfoAndComponentContract(t *testing.T) {+ contents := NewQueritContentsTool()+ if contents.helper.client.Timeout != 65*time.Second {+ t.Fatalf("HTTP timeout = %s, want 65s", contents.helper.client.Timeout)+ }+ info, err := contents.Info(context.Background())+ if err != nil || info.Name != queritContentsToolName || info.ParamsOneOf == nil {+ t.Fatalf("Info = %#v, %v", info, err)+ }+ encoded, _ := json.Marshal(info)+ if strings.Contains(string(encoded), "api_key") {+ t.Fatalf("Info exposed API key: %s", encoded)+ }+ spec := contents.ComponentSpec()+ if spec.Inputs["urls"] == "" || spec.Outputs["json"] == "" || !spec.PreserveJSONNumbers {+ t.Fatalf("ComponentSpec = %#v", spec)+ }+ if len(spec.InputForm) != 1 || spec.InputForm["urls"] == nil {+ t.Fatalf("InputForm = %#v, want URLs only", spec.InputForm)+ }+ response := map[string]any{"search_id": "crawl-1", "results": []any{map[string]any{"content": "page"}}}+ outputs := contents.BuildComponentOutputs(response)+ if outputs["json"].(map[string]any)["search_id"] != "crawl-1" {+ t.Fatalf("outputs = %#v", outputs)+ }+}diff --git a/internal/agent/tool/registry.go b/internal/agent/tool/registry.goindex f5143b9ec2..4f8eb71d75 100644--- a/internal/agent/tool/registry.go+++ b/internal/agent/tool/registry.go@@ -55,6 +55,7 @@ var registry = map[string]Factory{"pubmed": buildPubMedTool,"qweather": noConfig("qweather", func() einotool.BaseTool { return NewQWeatherTool() }),"querit": buildQueritTool,+ "querit_contents": buildQueritContentsTool,"querit_search": buildQueritTool,"retrieval": buildRetrievalTool,"search_my_dataset": buildRetrievalTool,@@ -78,6 +79,7 @@ var canvasToolNames = map[string]string{"codeexec": "code_exec","googlescholar": "google_scholar","keenablesearch": "keenable",+ "queritcontents": "querit_contents","queritsearch": "querit_search","tavilyextract": "tavily_extract","tavilysearch": "tavily",@@ -657,6 +659,42 @@ func buildQueritTool(params map[string]any) (einotool.BaseTool, error) {return newQueritTool(nil, nil, defaults, nil), nil}+func buildQueritContentsTool(params map[string]any) (einotool.BaseTool, error) {+ defaults := queritContentsParams{}+ if value, exists := params["api_key"]; exists {+ apiKey, valid := value.(string)+ if !valid {+ return nil, fmt.Errorf("agent tool: tool %q requires string node-level param api_key", queritContentsToolName)+ }+ defaults.APIKey = apiKey+ }+ if value, exists := params["urls"]; exists {+ defaults.URLs = value+ }+ if value, exists := params["format"]; exists {+ format, valid := value.(string)+ if !valid || (format != "text" && format != "markdown" && format != "html") {+ return nil, fmt.Errorf("agent tool: tool %q has unsupported format %q", queritContentsToolName, format)+ }+ defaults.Format = format+ }+ if value, exists := params["crawl_timeout"]; exists {+ crawlTimeout, valid := strictInt(value)+ if !valid || crawlTimeout < 1 || crawlTimeout > 60 {+ return nil, fmt.Errorf("agent tool: tool %q requires integer node-level param crawl_timeout within [1, 60]", queritContentsToolName)+ }+ defaults.CrawlTimeout = crawlTimeout+ }+ if value, exists := params["extras_meta"]; exists {+ extrasMeta, valid := value.(bool)+ if !valid {+ return nil, fmt.Errorf("agent tool: tool %q requires boolean node-level param extras_meta", queritContentsToolName)+ }+ defaults.ExtrasMeta = extrasMeta+ }+ return newQueritContentsTool(nil, nil, defaults, nil), nil+}+func buildKeenableTool(params map[string]any) (einotool.BaseTool, error) {defaults := keenableParams{}apiKey := ""diff --git a/internal/agent/tool/registry_test.go b/internal/agent/tool/registry_test.goindex 1f71a40f9f..a1d2151ba9 100644--- a/internal/agent/tool/registry_test.go+++ b/internal/agent/tool/registry_test.go@@ -48,6 +48,7 @@ func TestBuildByName_CanvasComponentNames(t *testing.T) {{name: "CodeExec", wantToolName: "execute_code"},{name: "GoogleScholar", wantToolName: "google_scholar_search"},{name: "KeenableSearch", wantToolName: "keenable_search"},+ {name: "QueritContents", wantToolName: "querit_contents"},{name: "QueritSearch", wantToolName: "querit_search"},{name: "TavilyExtract", wantToolName: "tavily_extract"},{name: "TavilySearch", wantToolName: "tavily_search"},@@ -134,13 +135,34 @@ func TestBuildByName_QueritAliases(t *testing.T) {}}+func TestBuildByName_QueritContentsAliases(t *testing.T) {+ for _, name := range []string{"querit_contents", "queritcontents", "QueritContents"} {+ built, err := BuildByName(name, map[string]any{+ "api_key": "stored-key",+ "format": "html",+ "crawl_timeout": float64(20),+ "extras_meta": true,+ })+ if err != nil {+ t.Fatalf("BuildByName(%q): %v", name, err)+ }+ contents, ok := built.(*QueritContentsTool)+ if !ok {+ t.Fatalf("BuildByName(%q) returned %T, want *QueritContentsTool", name, built)+ }+ if contents.defaults.Format != "html" || contents.defaults.CrawlTimeout != 20 || !contents.defaults.ExtrasMeta {+ t.Fatalf("BuildByName(%q) defaults = %#v", name, contents.defaults)+ }+ }+}+func TestBuildAll_AllRegisteredTools(t *testing.T) {// Every key in registry.names := []string{"akshare", "arxiv", "bgpt", "code_exec", "crawler", "deepl","duckduckgo", "email", "exesql", "execute_sql", "github", "google","google_scholar", "google_scholar_search", "jin10", "keenable", "pubmed", "qweather",- "querit", "querit_search",+ "querit", "querit_contents", "querit_search","retrieval", "search_my_dataset", "search_my_dateset", "searxng","tavily", "tavily_extract", "tushare", "web_crawler", "wencai", "wikipedia", "wikipedia_search","yahoo_finance",@@ -204,7 +226,7 @@ func TestToolRegistry_SchemasAreComplete(t *testing.T) {"akshare", "arxiv", "bgpt", "code_exec", "crawler", "deepl","duckduckgo", "email", "execute_sql", "exesql", "github", "google","google_scholar", "google_scholar_search", "jin10", "keenable", "pubmed", "qweather",- "querit", "querit_search",+ "querit", "querit_contents", "querit_search","retrieval", "search_my_dataset", "search_my_dateset", "searxng","tavily", "tavily_extract", "tushare", "web_crawler", "wencai", "wikipedia", "wikipedia_search","yahoo_finance",@@ -275,6 +297,7 @@ func TestToolRegistry_SchemasAreComplete(t *testing.T) {"wikipedia": "wikipedia_search","wikipedia_search": "wikipedia_search","querit": "querit_search",+ "querit_contents": "querit_contents","querit_search": "querit_search",}for _, name := range names {diff --git a/test/unit_test/agent/tools/test_querit_contents_unit.py b/test/unit_test/agent/tools/test_querit_contents_unit.pynew file mode 100644index 0000000000..dbf4f8df8c--- /dev/null+++ b/test/unit_test/agent/tools/test_querit_contents_unit.py@@ -0,0 +1,212 @@+#+# Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+#++import logging++import pytest++import agent.tools.querit as querit_module+from agent.tools.querit import QueritContents, QueritContentsParam+++class _FakeResponse:+ def __init__(self, payload, status_code=200):+ self._payload = payload+ self.status_code = status_code++ def json(self):+ return self._payload++ def raise_for_status(self):+ if self.status_code >= 400:+ raise querit_module.requests.HTTPError(f"{self.status_code} error", response=self)+++def _make_tool(api_key="test-api-key"):+ tool = QueritContents.__new__(QueritContents)+ param = QueritContentsParam()+ param.api_key = api_key+ param.delay_after_error = 0+ tool._param = param+ tool.check_if_canceled = lambda *args, **kwargs: False++ outputs = {}+ tool.set_output = lambda key, value: outputs.__setitem__(key, value)+ tool.output = lambda key=None: outputs.get(key) if key else outputs+ return tool, outputs+++def test_contents_posts_documented_defaults_and_preserves_response(monkeypatch):+ raw_response = {+ "error_code": 0,+ "error_msg": "",+ "search_id": "crawl-1",+ "results": [+ {+ "id": "1",+ "url": "https://example.com/article",+ "content": "# Article",+ "extrasMeta": {"title": "Article", "siteName": "Example"},+ }+ ],+ "statuses": [{"id": "1", "status": "success"}],+ "searchTime": 1,+ }+ calls = []++ def fake_post(url, **kwargs):+ calls.append((url, kwargs))+ return _FakeResponse(raw_response)++ monkeypatch.setattr(querit_module.requests, "post", fake_post)+ tool, outputs = _make_tool()++ result = tool._invoke(urls=["https://example.com/article"])++ assert result == raw_response+ assert calls == [+ (+ "https://api.querit.ai/v1/contents",+ {+ "headers": {+ "Accept": "application/json",+ "Authorization": "Bearer test-api-key",+ "Content-Type": "application/json",+ },+ "json": {+ "urls": ["https://example.com/article"],+ "format": "markdown",+ "crawlTimeout": 10,+ "extrasMeta": False,+ },+ "timeout": querit_module.DEFAULT_TIMEOUT,+ },+ )+ ]+ assert outputs["json"] == raw_response+++def test_contents_accepts_canvas_url_string_and_runtime_options(monkeypatch):+ calls = []++ def fake_post(url, **kwargs):+ calls.append(kwargs)+ return _FakeResponse({"results": [], "statuses": []})++ monkeypatch.setattr(querit_module.requests, "post", fake_post)+ tool, _ = _make_tool()++ tool._invoke(+ urls="https://one.example, https://two.example",+ format="html",+ crawl_timeout=60,+ extras_meta=True,+ )++ assert calls[0]["json"] == {+ "urls": ["https://one.example", "https://two.example"],+ "format": "html",+ "crawlTimeout": 60,+ "extrasMeta": True,+ }+ assert calls[0]["timeout"] == 65+++def test_contents_param_normalizes_canvas_url_string_before_validation():+ param = QueritContentsParam()+ param.urls = "https://one.example, https://two.example"+ param.format = "markdown"+ param.crawl_timeout = 10+ param.extras_meta = False++ param.check()++ assert param.urls == ["https://one.example", "https://two.example"]+ assert param.get_input_form() == {"urls": {"name": "URLs", "type": "line"}}+++ ("kwargs", "message"),+ [+ ({"urls": []}, "between 1 and 10"),+ ({"urls": [f"https://{index}.example" for index in range(11)]}, "between 1 and 10"),+ ({"urls": ["example.com"]}, "absolute HTTP or HTTPS"),+ ({"urls": ["file:///tmp/page"]}, "absolute HTTP or HTTPS"),+ ({"urls": ["https://example.com"], "format": "xml"}, "format must be"),+ ({"urls": ["https://example.com"], "crawl_timeout": 0}, "integer from 1 to 60"),+ ({"urls": ["https://example.com"], "extras_meta": 1}, "must be a boolean"),+ ],+)+def test_contents_rejects_invalid_inputs(kwargs, message):+ tool, outputs = _make_tool()++ result = tool._invoke(**kwargs)++ assert message in result+ assert message in outputs["_ERROR"]+++ ("payload", "message"),+ [+ ([], "JSON object"),+ ({"results": {}}, "results must be an array"),+ ({"results": [], "statuses": {}}, "statuses must be an array"),+ ],+)+def test_contents_rejects_malformed_response(monkeypatch, payload, message):+ monkeypatch.setattr(querit_module.requests, "post", lambda *args, **kwargs: _FakeResponse(payload))+ tool, outputs = _make_tool()++ result = tool._invoke(urls=["https://example.com"])++ assert message in result+ assert message in outputs["_ERROR"]+++def test_contents_redacts_api_key_from_errors_and_logs(monkeypatch, caplog):+ secret = f"secret-contents-key-{id(caplog)}"++ def fake_post(*args, **kwargs):+ raise querit_module.requests.ConnectionError(f"connection failed for {secret}")++ monkeypatch.setattr(querit_module.requests, "post", fake_post)+ tool, outputs = _make_tool(api_key=secret)++ with caplog.at_level(logging.ERROR):+ result = tool._invoke(urls=["https://example.com"])++ assert secret not in result+ assert secret not in outputs["_ERROR"]+ assert secret not in caplog.text+ assert "[REDACTED]" in result+++def test_contents_contract_and_dynamic_discovery():+ import agent.tools as tools_package++ metadata = QueritContentsParam().get_meta()["function"]+ assert metadata["name"] == "querit_contents"+ assert metadata["parameters"]["required"] == ["urls"]+ assert set(metadata["parameters"]["properties"]) == {+ "urls",+ "format",+ "crawl_timeout",+ "extras_meta",+ }+ assert "api_key" not in metadata["parameters"]["properties"]+ assert tools_package.QueritContents is QueritContents+ assert tools_package.QueritContentsParam is QueritContentsParamdiff --git a/web/src/components/operator-icon.tsx b/web/src/components/operator-icon.tsxindex 79982d10b3..9e8528c37e 100644--- a/web/src/components/operator-icon.tsx+++ b/web/src/components/operator-icon.tsx@@ -74,6 +74,7 @@ export const SVGIconMap = {[Operator.KeenableSearch]: 'keenable',[Operator.TavilyExtract]: 'tavily',[Operator.TavilySearch]: 'tavily',+ [Operator.QueritContents]: 'querit',[Operator.QueritSearch]: 'querit',[Operator.Wikipedia]: 'wikipedia',[Operator.YahooFinance]: 'yahoo-finance',@@ -123,7 +124,7 @@ const OperatorIcon = ({ name, className }: IProps) => {const svgIcon = SVGIconMap[name as keyof typeof SVGIconMap];const LucideIcon = LucideIconMap[name as keyof typeof LucideIconMap];- if (name === Operator.QueritSearch) {+ if (name === Operator.QueritContents || name === Operator.QueritSearch) {return (<imgsrc={queritLogo}diff --git a/web/src/constants/agent.tsx b/web/src/constants/agent.tsxindex 6ef6225746..69052061eb 100644--- a/web/src/constants/agent.tsx+++ b/web/src/constants/agent.tsx@@ -111,6 +111,7 @@ export enum Operator {Tool = 'Tool',TavilySearch = 'TavilySearch',TavilyExtract = 'TavilyExtract',+ QueritContents = 'QueritContents',QueritSearch = 'QueritSearch',UserFillUp = 'UserFillUp',StringTransform = 'StringTransform',diff --git a/web/src/locales/en.ts b/web/src/locales/en.tsindex d5fedbac28..5dc1ccfb77 100644--- a/web/src/locales/en.ts+++ b/web/src/locales/en.ts@@ -2583,6 +2583,15 @@ Best for: Documents with flowing, contextually connected content — such as booqueritLanguageInclude: 'Languages to include',queritLanguageIncludeTip: 'Return results in the specified languages.',queritListPlaceholder: 'Enter a value',+ queritContentsUrls: 'URLs',+ queritContentsUrlsTip:+ 'Enter between one and ten absolute HTTP or HTTPS URLs, separated by commas.',+ queritContentsTimeout: 'Crawl timeout',+ queritContentsTimeoutTip:+ 'Set the per-page crawl timeout from 1 to 60 seconds.',+ queritContentsMetadata: 'Include page metadata',+ queritContentsMetadataTip:+ 'Return page title, publication time, site name, and site icon when available.',Days: 'Days',comma: 'Comma',semicolon: 'Semicolon',@@ -3241,6 +3250,9 @@ This process aggregates variables from multiple branches into a single variablequeritSearch: 'Querit search',queritSearchDescription:'Search the web with Querit and return source-backed results for agents.',+ queritContents: 'Querit contents',+ queritContentsDescription:+ 'Crawl web pages with Querit and return their contents.',tavilyExtract: 'Tavily extract',tavilyExtractDescription: 'Tavily Extract',log: 'Log',@@ -3274,6 +3286,7 @@ This process aggregates variables from multiple branches into a single variabletextProcessing: 'Tidying up text',tavilySearch: 'Searching the web',queritSearch: 'Searching the web with Querit',+ queritContents: 'Reading web pages with Querit',tavilyExtract: 'Reading the page',exeSQL: 'Querying database',google: 'Searching the web',diff --git a/web/src/locales/zh.ts b/web/src/locales/zh.tsindex 67a6bf7c84..4b9a8fd5ad 100644--- a/web/src/locales/zh.ts+++ b/web/src/locales/zh.ts@@ -2218,6 +2218,15 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取实体和关系queritLanguageInclude: '包含的语言',queritLanguageIncludeTip: '返回使用指定语言的结果。',queritListPlaceholder: '请输入内容',+ queritContentsUrls: '网页地址',+ queritContentsUrlsTip:+ '请输入 1 到 10 个完整的 HTTP 或 HTTPS 地址,并使用英文逗号分隔。',+ queritContentsTimeout: '抓取超时',+ queritContentsTimeoutTip:+ '设置每个页面的抓取超时时间,范围为 1 到 60 秒。',+ queritContentsMetadata: '包含页面元数据',+ queritContentsMetadataTip:+ '在可用时返回页面标题、发布时间、站点名称和站点图标。',days: '天数',comma: '逗号',semicolon: '分号',@@ -2838,6 +2847,8 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取实体和关系queritSearch: 'Querit 搜索',queritSearchDescription:'使用 Querit 搜索网络,并为智能体返回带来源的搜索结果。',+ queritContents: 'Querit 网页内容',+ queritContentsDescription: '使用 Querit 抓取网页并返回页面内容。',tavilyExtract: 'Tavily 提取',tavilyExtractDescription: 'Tavily 提取',log: '日志',@@ -2859,6 +2870,7 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取实体和关系textProcessing: '整理文字',tavilySearch: '正在网上搜索',queritSearch: '正在使用 Querit 搜索网络',+ queritContents: '正在使用 Querit 读取网页',tavilyExtract: '读取网页内容',exeSQL: '查询数据库',google: '正在网上搜索',diff --git a/web/src/pages/agent/canvas/node/dropdown/accordion-operators.tsx b/web/src/pages/agent/canvas/node/dropdown/accordion-operators.tsxindex a81b362649..feb419d487 100644--- a/web/src/pages/agent/canvas/node/dropdown/accordion-operators.tsx+++ b/web/src/pages/agent/canvas/node/dropdown/accordion-operators.tsx@@ -109,6 +109,7 @@ export function AccordionOperators({operators={[Operator.TavilySearch,Operator.TavilyExtract,+ Operator.QueritContents,Operator.QueritSearch,Operator.ExeSQL,Operator.Google,diff --git a/web/src/pages/agent/constant/index.tsx b/web/src/pages/agent/constant/index.tsxindex 2ab7360d2f..1b88803bc0 100644--- a/web/src/pages/agent/constant/index.tsx+++ b/web/src/pages/agent/constant/index.tsx@@ -592,6 +592,26 @@ export const initialQueritValues = {},};+export enum QueritContentFormat {+ Text = 'text',+ Markdown = 'markdown',+ Html = 'html',+}++export const initialQueritContentsValues = {+ api_key: '',+ urls: '',+ format: QueritContentFormat.Markdown,+ crawl_timeout: 10,+ extras_meta: false,+ outputs: {+ json: {+ value: {},+ type: 'object',+ },+ },+};+export enum TavilyExtractDepth {Basic = 'basic',Advanced = 'advanced',@@ -742,6 +762,7 @@ export const RestrictedUpstreamMap = {[Operator.WaitingDialogue]: [Operator.Begin],[Operator.Agent]: [Operator.Begin],[Operator.TavilySearch]: [Operator.Begin],+ [Operator.QueritContents]: [Operator.Begin],[Operator.QueritSearch]: [Operator.Begin],[Operator.TavilyExtract]: [Operator.Begin],[Operator.StringTransform]: [Operator.Begin],@@ -798,6 +819,7 @@ export const NodeMap = {[Operator.Agent]: 'agentNode',[Operator.Tool]: 'toolNode',[Operator.TavilySearch]: 'ragNode',+ [Operator.QueritContents]: 'ragNode',[Operator.QueritSearch]: 'ragNode',[Operator.UserFillUp]: 'ragNode',[Operator.StringTransform]: 'ragNode',diff --git a/web/src/pages/agent/form-sheet/form-config-map.tsx b/web/src/pages/agent/form-sheet/form-config-map.tsxindex 8176fe64a5..a8fb6af7b4 100644--- a/web/src/pages/agent/form-sheet/form-config-map.tsx+++ b/web/src/pages/agent/form-sheet/form-config-map.tsx@@ -26,6 +26,7 @@ import LoopForm from '../form/loop-form';import MessageForm from '../form/message-form';import ParserForm from '../form/parser-form';import PubMedForm from '../form/pubmed-form';+import QueritContentsForm from '../form/querit-contents-form';import QueritForm from '../form/querit-form';import BGPTForm from '../form/bgpt-form';import RetrievalForm from '../form/retrieval-form/next';@@ -146,6 +147,9 @@ export const FormConfigMap = {[Operator.TavilySearch]: {component: TavilyForm,},+ [Operator.QueritContents]: {+ component: QueritContentsForm,+ },[Operator.QueritSearch]: {component: QueritForm,},diff --git a/web/src/pages/agent/form/agent-form/tool-popover/tool-command.tsx b/web/src/pages/agent/form/agent-form/tool-popover/tool-command.tsxindex ff6172ca74..a10b33b293 100644--- a/web/src/pages/agent/form/agent-form/tool-popover/tool-command.tsx+++ b/web/src/pages/agent/form/agent-form/tool-popover/tool-command.tsx@@ -23,6 +23,7 @@ const Menus = [list: [Operator.TavilySearch,Operator.TavilyExtract,+ Operator.QueritContents,Operator.QueritSearch,Operator.Google,// Operator.Bing,diff --git a/web/src/pages/agent/form/querit-contents-form/index.tsx b/web/src/pages/agent/form/querit-contents-form/index.tsxnew file mode 100644index 0000000000..6db655c308--- /dev/null+++ b/web/src/pages/agent/form/querit-contents-form/index.tsx@@ -0,0 +1,138 @@+import { FormContainer } from '@/components/form-container';+import {+ Form,+ FormControl,+ FormField,+ FormItem,+ FormLabel,+ FormMessage,+} from '@/components/ui/form';+import { Input } from '@/components/ui/input';+import { RAGFlowSelect } from '@/components/ui/select';+import { Switch } from '@/components/ui/switch';+import { useTranslate } from '@/hooks/common-hooks';+import { buildOptions } from '@/utils/form';+import { zodResolver } from '@hookform/resolvers/zod';+import { memo } from 'react';+import { useForm } from 'react-hook-form';+import { z } from 'zod';+import {+ QueritContentFormat,+ initialQueritContentsValues,+} from '../../constant';+import { useFormValues } from '../../hooks/use-form-values';+import { useWatchFormChange } from '../../hooks/use-watch-form-change';+import { INextOperatorForm } from '../../interface';+import { buildOutputList } from '../../utils/build-output-list';+import { ApiKeyField } from '../components/api-key-field';+import { FormWrapper } from '../components/form-wrapper';+import { Output } from '../components/output';+import { PromptEditor } from '../components/prompt-editor';++const outputList = buildOutputList(initialQueritContentsValues.outputs);++const FormSchema = z.object({+ api_key: z.string(),+ urls: z.string().min(1),+ format: z.enum([+ QueritContentFormat.Text,+ QueritContentFormat.Markdown,+ QueritContentFormat.Html,+ ]),+ crawl_timeout: z.coerce.number().int().min(1).max(60),+ extras_meta: z.boolean(),+});++function QueritContentsForm({ node }: INextOperatorForm) {+ const { t } = useTranslate('flow');+ const values = useFormValues(initialQueritContentsValues, node);+ const form = useForm<z.infer<typeof FormSchema>>({+ defaultValues: values,+ resolver: zodResolver(FormSchema),+ mode: 'onChange',+ });++ useWatchFormChange(node?.id, form);++ return (+ <Form {...form}>+ <FormWrapper>+ <FormContainer>+ <ApiKeyField />+ <FormField+ control={form.control}+ name="urls"+ render={({ field }) => (+ <FormItem>+ <FormLabel tooltip={t('queritContentsUrlsTip')}>+ {t('queritContentsUrls')}+ </FormLabel>+ <FormControl>+ <PromptEditor+ {...field}+ multiLine={false}+ showToolbar={false}+ />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />+ <FormField+ control={form.control}+ name="format"+ render={({ field }) => (+ <FormItem>+ <FormLabel>{t('format')}</FormLabel>+ <FormControl>+ <RAGFlowSelect+ {...field}+ options={buildOptions(QueritContentFormat)}+ />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />+ <FormField+ control={form.control}+ name="crawl_timeout"+ render={({ field }) => (+ <FormItem>+ <FormLabel tooltip={t('queritContentsTimeoutTip')}>+ {t('queritContentsTimeout')}+ </FormLabel>+ <FormControl>+ <Input type="number" min={1} max={60} step={1} {...field} />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />+ <FormField+ control={form.control}+ name="extras_meta"+ render={({ field }) => (+ <FormItem className="flex items-center justify-between">+ <FormLabel tooltip={t('queritContentsMetadataTip')}>+ {t('queritContentsMetadata')}+ </FormLabel>+ <FormControl>+ <Switch+ checked={field.value}+ onCheckedChange={field.onChange}+ />+ </FormControl>+ </FormItem>+ )}+ />+ </FormContainer>+ </FormWrapper>+ <div className="p-5">+ <Output list={outputList} />+ </div>+ </Form>+ );+}++export default memo(QueritContentsForm);diff --git a/web/src/pages/agent/form/tool-form/constant.tsx b/web/src/pages/agent/form/tool-form/constant.tsxindex 772ed10c6a..e6b369429d 100644--- a/web/src/pages/agent/form/tool-form/constant.tsx+++ b/web/src/pages/agent/form/tool-form/constant.tsx@@ -14,7 +14,7 @@ import QueritForm from './querit-form';import BGPTForm from './bgpt-form';import RetrievalForm from './retrieval-form';import SearXNGForm from './searxng-form';-import TavilyForm from './tavily-form';+import ApiKeyToolForm from './tavily-form';import WenCaiForm from './wencai-form';import WikipediaForm from './wikipedia-form';import YahooFinanceForm from './yahoo-finance-form';@@ -35,8 +35,9 @@ export const ToolFormConfigMap = {[Operator.YahooFinance]: YahooFinanceForm,[Operator.Crawler]: CrawlerForm,[Operator.Email]: EmailForm,- [Operator.TavilySearch]: TavilyForm,- [Operator.TavilyExtract]: TavilyForm,+ [Operator.TavilySearch]: ApiKeyToolForm,+ [Operator.TavilyExtract]: ApiKeyToolForm,+ [Operator.QueritContents]: ApiKeyToolForm,[Operator.QueritSearch]: QueritForm,[Operator.WenCai]: WenCaiForm,[Operator.SearXNG]: SearXNGForm,diff --git a/web/src/pages/agent/hooks/use-add-node.ts b/web/src/pages/agent/hooks/use-add-node.tsindex 1cbe828239..cc9b6dfd45 100644--- a/web/src/pages/agent/hooks/use-add-node.ts+++ b/web/src/pages/agent/hooks/use-add-node.ts@@ -38,6 +38,7 @@ import {initialParserValues,initialPubMedValues,initialBGPTValues,+ initialQueritContentsValues,initialQueritValues,initialRetrievalValues,initialRewriteQuestionValues,@@ -168,6 +169,7 @@ export const useInitializeOperatorParams = () => {[Operator.Agent]: { ...initialAgentValues, llm_id: llmId },[Operator.Tool]: {},[Operator.TavilySearch]: initialTavilyValues,+ [Operator.QueritContents]: initialQueritContentsValues,[Operator.QueritSearch]: initialQueritValues,[Operator.KeenableSearch]: initialKeenableValues,[Operator.UserFillUp]: initialUserFillUpValues,diff --git a/web/src/pages/agent/hooks/use-agent-tool-initial-values.ts b/web/src/pages/agent/hooks/use-agent-tool-initial-values.tsindex 3250a55fde..814afc3d72 100644--- a/web/src/pages/agent/hooks/use-agent-tool-initial-values.ts+++ b/web/src/pages/agent/hooks/use-agent-tool-initial-values.ts@@ -23,6 +23,8 @@ export function useAgentToolInitialValues() {};case Operator.QueritSearch:return getQueritAgentInitialValues(initialValues);+ case Operator.QueritContents:+ return { api_key: '' };case Operator.ExeSQL:return omit(initialValues, 'sql');case Operator.Bing:diff --git a/web/src/pages/agent/log-sheet/tool-name.test.ts b/web/src/pages/agent/log-sheet/tool-name.test.tsindex 2f99622724..538cff9b9e 100644--- a/web/src/pages/agent/log-sheet/tool-name.test.ts+++ b/web/src/pages/agent/log-sheet/tool-name.test.ts@@ -1,5 +1,6 @@jest.mock('@/constants/agent', () => ({Operator: {+ QueritContents: 'QueritContents',QueritSearch: 'QueritSearch',},}));@@ -15,6 +16,13 @@ describe('getToolOperatorName', () => {},);+ it.each(['QueritContents', 'querit_contents'])(+ 'maps the Querit Contents timeline name %p to its operator',+ (toolName) => {+ expect(getToolOperatorName(toolName)).toBe(Operator.QueritContents);+ },+ );+it.each([undefined, null, ''])('returns an empty name for the missing value %p',(toolName) => {diff --git a/web/src/pages/agent/log-sheet/tool-name.ts b/web/src/pages/agent/log-sheet/tool-name.tsindex 80e87f2c15..3bcb718060 100644--- a/web/src/pages/agent/log-sheet/tool-name.ts+++ b/web/src/pages/agent/log-sheet/tool-name.ts@@ -9,6 +9,9 @@ export function getToolOperatorName(toolName?: string | null) {if (normalizedName === Operator.QueritSearch.toLowerCase()) {return Operator.QueritSearch;}+ if (normalizedName === Operator.QueritContents.toLowerCase()) {+ return Operator.QueritContents;+ }return toolName.split('_')diff --git a/web/src/pages/agent/log-sheet/tool-timeline-item.tsx b/web/src/pages/agent/log-sheet/tool-timeline-item.tsxindex f7d7d71a6c..6666f641c5 100644--- a/web/src/pages/agent/log-sheet/tool-timeline-item.tsx+++ b/web/src/pages/agent/log-sheet/tool-timeline-item.tsx@@ -29,6 +29,7 @@ type IToolIcon =| Operator.BGPT| Operator.TavilyExtract| Operator.TavilySearch+ | Operator.QueritContents| Operator.QueritSearch| Operator.KeenableSearch| Operator.Wikipediadiff --git a/web/src/pages/agent/utils/clear-sensitive-fields.test.ts b/web/src/pages/agent/utils/clear-sensitive-fields.test.tsindex 1fd1a4fd1e..f19b77469c 100644--- a/web/src/pages/agent/utils/clear-sensitive-fields.test.ts+++ b/web/src/pages/agent/utils/clear-sensitive-fields.test.ts@@ -5,6 +5,7 @@ jest.mock('@/constants/agent', () => ({Google: 'Google',KeenableSearch: 'KeenableSearch',BGPT: 'Bing',+ QueritContents: 'QueritContents',QueritSearch: 'QueritSearch',},}));@@ -44,28 +45,31 @@ describe('clearSensitiveFields', () => {expect(dsl.tools[0].params.api_key).toBe('querit-secret');});- it.each(['querit', 'querit_search', 'queritsearch'])(- 'clears a Querit API key for the %s registry alias',- (componentName) => {- const dsl = {- tools: [- {- component_name: componentName,- params: {- api_key: 'querit-secret',- count: 5,- },+ it.each([+ 'querit',+ 'querit_contents',+ 'queritcontents',+ 'querit_search',+ 'queritsearch',+ ])('clears a Querit API key for the %s registry alias', (componentName) => {+ const dsl = {+ tools: [+ {+ component_name: componentName,+ params: {+ api_key: 'querit-secret',+ count: 5,},- ],- };+ },+ ],+ };- const sanitized = clearSensitiveFields(dsl);+ const sanitized = clearSensitiveFields(dsl);- expect(sanitized.tools[0].params.api_key).toBe('');- expect(sanitized.tools[0].params.count).toBe(5);- expect(dsl.tools[0].params.api_key).toBe('querit-secret');- },- );+ expect(sanitized.tools[0].params.api_key).toBe('');+ expect(sanitized.tools[0].params.count).toBe(5);+ expect(dsl.tools[0].params.api_key).toBe('querit-secret');+ });it('clears a standalone Querit Canvas key from graph and components', () => {const dsl = {diff --git a/web/src/pages/agent/utils/clear-sensitive-fields.ts b/web/src/pages/agent/utils/clear-sensitive-fields.tsindex 2129cd39f0..d7d6c59d1b 100644--- a/web/src/pages/agent/utils/clear-sensitive-fields.ts+++ b/web/src/pages/agent/utils/clear-sensitive-fields.ts@@ -7,6 +7,7 @@ const apiKeyOperators = [Operator.Google,Operator.KeenableSearch,Operator.BGPT,+ Operator.QueritContents,Operator.QueritSearch,];@@ -15,7 +16,7 @@ function isQueritOperator(value: unknown) {return false;}- return ['querit', 'queritsearch'].includes(+ return ['querit', 'queritcontents', 'queritsearch'].includes(value.replace(/_/g, '').toLowerCase(),);}