abelworkflow 1.1.2 → 1.2.0

package/skills/grok-search/scripts/groksearch_cli.py

@@ -15,6 +15,8 @@ from pathlib import Path
 from typing import Optional
 from urllib.parse import urlsplit, urlunsplit
 
+sys.dont_write_bytecode = True
+
 from _dotenv import load_dotenv
 
 try:
@@ -22,13 +24,10 @@ try:
     from tenacity import AsyncRetrying, retry_if_exception, stop_after_attempt, wait_random_exponential
     from tenacity.wait import wait_base
 except ImportError:
-    print("Error: 所需包未安装。请运行: python scripts/groksearch_entry.py --help 或 pip install httpx tenacity", file=sys.stderr)
+    print("Error: 所需包未安装。请运行: python -m pip install -r requirements.txt", file=sys.stderr)
     sys.exit(1)
 
 
-load_dotenv()
-
-
 # ============================================================================
 # 配置
 # ============================================================================
@@ -119,19 +118,9 @@ class Config:
     def tavily_api_key(self) -> Optional[str]:
         return os.getenv("TAVILY_API_KEY") or None
 
-    def _apply_model_suffix(self, model: str) -> str:
-        try:
-            url = self.grok_api_url
-        except ValueError:
-            return model
-        if "openrouter" in url and ":online" not in model:
-            return f"{model}:online"
-        return model
-
     @property
     def grok_model(self) -> str:
-        model = os.getenv("GROK_MODEL") or self._DEFAULT_MODEL
-        return self._apply_model_suffix(model)
+        return os.getenv("GROK_MODEL") or self._DEFAULT_MODEL
 
     @staticmethod
     def _mask_api_key(key: str) -> str:
@@ -214,6 +203,7 @@ def _emit_tavily_warning(message: str) -> None:
 # ============================================================================
 
 RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504}
+MAX_RESPONSE_BYTES = 10 * 1024 * 1024
 
 
 class StreamEmbeddedError(Exception):
@@ -224,6 +214,44 @@ class EmptyStreamError(Exception):
     """流式响应解析完成但内容为空。"""
 
 
+class ResponseTooLargeError(ValueError):
+    """Response exceeded the configured in-memory byte limit."""
+
+
+async def _iter_response_bytes(response, max_bytes: Optional[int] = None):
+    limit = MAX_RESPONSE_BYTES if max_bytes is None else max_bytes
+    total = 0
+    async for chunk in response.aiter_bytes():
+        total += len(chunk)
+        if total > limit:
+            raise ResponseTooLargeError(f"API 响应超过 {limit} 字节限制")
+        yield chunk
+
+
+async def _read_response_bytes(response, max_bytes: Optional[int] = None) -> bytes:
+    body = bytearray()
+    async for chunk in _iter_response_bytes(response, max_bytes):
+        body.extend(chunk)
+    return bytes(body)
+
+
+async def _read_json_response(response):
+    return json.loads(await _read_response_bytes(response))
+
+
+def _extract_chat_content(data, container: str) -> str:
+    if not isinstance(data, dict):
+        return ""
+    choices = data.get("choices")
+    if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
+        return ""
+    payload = choices[0].get(container)
+    if not isinstance(payload, dict):
+        return ""
+    content = payload.get("content")
+    return content if isinstance(content, str) else ""
+
+
 def _is_retryable_exception(exc) -> bool:
     if isinstance(exc, (StreamEmbeddedError, EmptyStreamError)):
         return True
@@ -237,6 +265,7 @@ def _is_retryable_exception(exc) -> bool:
 class _WaitWithRetryAfter(wait_base):
     def __init__(self, multiplier: float, max_wait: int):
         self._base_wait = wait_random_exponential(multiplier=multiplier, max=max_wait)
+        self._max_wait = max_wait
         self._protocol_error_base = 3.0
 
     def __call__(self, retry_state):
@@ -256,13 +285,13 @@ class _WaitWithRetryAfter(wait_base):
             return None
         header = header.strip()
         if header.isdigit():
-            return float(header)
+            return min(float(header), self._max_wait)
         try:
             retry_dt = parsedate_to_datetime(header)
             if retry_dt.tzinfo is None:
                 retry_dt = retry_dt.replace(tzinfo=timezone.utc)
             delay = (retry_dt - datetime.now(timezone.utc)).total_seconds()
-            return max(0.0, delay)
+            return min(max(0.0, delay), self._max_wait)
         except (TypeError, ValueError):
             return None
 
@@ -404,6 +433,23 @@ def _bracket_ipv6_authority(authority: str) -> str:
     return f"{prefix}[{target}]"
 
 
+def _validate_http_url(url: str) -> str:
+    parts = urlsplit(url)
+    try:
+        hostname = parts.hostname
+        parts.port
+    except ValueError as error:
+        raise ValueError(f"URL 端口无效: {url!r}") from error
+    if not parts.netloc or not hostname:
+        raise ValueError(f"URL 缺少主机名: {url!r}")
+    hostport = parts.netloc.rsplit("@", 1)[-1]
+    if hostport.endswith(":"):
+        raise ValueError(f"URL 端口无效: {url!r}")
+    if parts.username is not None or parts.password is not None:
+        raise ValueError("URL 不允许包含用户信息")
+    return url
+
+
 def normalize_url(url: str) -> str:
     s = (url or "").strip()
     while True:
@@ -431,7 +477,9 @@ def normalize_url(url: str) -> str:
         if parts.netloc:
             fixed_netloc = _bracket_ipv6_authority(parts.netloc)
             if fixed_netloc != parts.netloc:
-                return urlunsplit((parts.scheme, fixed_netloc, parts.path, parts.query, parts.fragment))
+                return _validate_http_url(
+                    urlunsplit((parts.scheme, fixed_netloc, parts.path, parts.query, parts.fragment))
+                )
         # Fix common invalid form like: http://::1 (IPv6 without brackets)
         if not parts.netloc and parts.path and ":" in parts.path and not parts.path.startswith("/"):
             rest = s[len(scheme_match.group(0)) :]
@@ -439,30 +487,22 @@ def normalize_url(url: str) -> str:
             if authority:
                 fixed_authority = _bracket_ipv6_authority(authority)
                 if fixed_authority != authority:
-                    return f"{scheme}://{fixed_authority}{remainder}"
-        return s
+                    return _validate_http_url(f"{scheme}://{fixed_authority}{remainder}")
+        return _validate_http_url(s)
 
     # Protocol-relative URL.
     if s.startswith("//"):
         authority, remainder = _split_authority_and_remainder(s)
-        if not authority:
-            raise ValueError(f"URL 缺少主机名: {url!r}")
         host = _extract_host_from_authority(authority)
-        if not host:
-            raise ValueError(f"URL 缺少主机名: {url!r}")
         scheme = "http" if _is_local_host(host) else "https"
         authority = _bracket_ipv6_authority(authority)
-        return f"{scheme}://{authority}{remainder}"
+        return _validate_http_url(f"{scheme}://{authority}{remainder}")
 
     authority, remainder = _split_authority_and_remainder(s)
-    if not authority:
-        raise ValueError(f"URL 缺少主机名: {url!r}")
     host = _extract_host_from_authority(authority)
-    if not host:
-        raise ValueError(f"URL 缺少主机名: {url!r}")
     scheme = "http" if _is_local_host(host) else "https"
     authority = _bracket_ipv6_authority(authority)
-    return f"{scheme}://{authority}{remainder}"
+    return _validate_http_url(f"{scheme}://{authority}{remainder}")
 
 
 def _materialize_docsify_markdown_url(url: str) -> Optional[str]:
@@ -624,18 +664,16 @@ class GrokSearchProvider:
             reraise=True,
         ):
             with attempt:
-                response = await client.post(
+                async with client.stream(
+                    "POST",
                     f"{self.api_url}/chat/completions",
                     headers=self._headers,
                     json=payload_copy,
                     timeout=_NON_STREAM_TIMEOUT,
-                )
-                response.raise_for_status()
-                data = response.json()
-                choices = data.get("choices", [])
-                if choices:
-                    return choices[0].get("message", {}).get("content", "")
-                return ""
+                ) as response:
+                    response.raise_for_status()
+                    data = await _read_json_response(response)
+                return _extract_chat_content(data, "message")
 
     async def _execute_stream(self, payload: dict) -> str:
         """流式请求（首选，chunk 保活避免网关超时）。"""
@@ -659,46 +697,75 @@ class GrokSearchProvider:
                     return await self._parse_streaming_response(response)
 
     async def _parse_streaming_response(self, response) -> str:
-        content = ""
-        full_body_buffer = []
-
-        async for line in response.aiter_lines():
-            line = line.strip()
+        content_parts = []
+        fallback_body = bytearray()
+        pending = bytearray()
+        scan_index = 0
+        saw_sse = False
+        cr, lf = b"\r\n"
+
+        def process_line(raw_line: bytes) -> None:
+            nonlocal saw_sse
+            line = raw_line.strip()
             if not line:
-                continue
-            full_body_buffer.append(line)
-
-            if line.startswith("data:"):
-                if line in ("data: [DONE]", "data:[DONE]"):
-                    continue
-                try:
-                    json_str = line[5:].lstrip()
-                    data = json.loads(json_str)
-                except (json.JSONDecodeError, IndexError):
+                return
+            if not line.startswith(b"data:"):
+                if not saw_sse:
+                    fallback_body.extend(raw_line)
+                    fallback_body.extend(b"\n")
+                return
+            if not saw_sse:
+                saw_sse = True
+                fallback_body.clear()
+            if line in (b"data: [DONE]", b"data:[DONE]"):
+                return
+            try:
+                data = json.loads(line[5:].lstrip())
+            except (json.JSONDecodeError, IndexError):
+                return
+            if isinstance(data, dict) and "error" in data:
+                raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
+            value = _extract_chat_content(data, "delta")
+            if value:
+                content_parts.append(value)
+
+        async for chunk in _iter_response_bytes(response):
+            pending.extend(chunk)
+            line_start = 0
+            while scan_index < len(pending):
+                separator = pending[scan_index]
+                if separator not in (cr, lf):
+                    scan_index += 1
                     continue
-                if isinstance(data, dict) and "error" in data:
-                    raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
-                choices = data.get("choices", [])
-                if choices:
-                    delta = choices[0].get("delta", {})
-                    if "content" in delta:
-                        content += delta["content"]
-
-        if not content and full_body_buffer:
+                if separator == cr and scan_index + 1 == len(pending):
+                    break
+                process_line(bytes(pending[line_start:scan_index]))
+                scan_index += 1
+                if separator == cr and scan_index < len(pending) and pending[scan_index] == lf:
+                    scan_index += 1
+                line_start = scan_index
+            if line_start:
+                del pending[:line_start]
+                scan_index -= line_start
+
+        if pending:
+            process_line(bytes(pending[:-1] if pending[-1] == cr else pending))
+
+        if content_parts:
+            return "".join(content_parts)
+
+        if fallback_body:
             try:
-                full_text = "".join(full_body_buffer)
-                data = json.loads(full_text)
+                data = json.loads(fallback_body)
                 if isinstance(data, dict) and "error" in data:
                     raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
-                if "choices" in data and data["choices"]:
-                    message = data["choices"][0].get("message", {})
-                    content = message.get("content", "")
+                content = _extract_chat_content(data, "message")
+                if content.strip():
+                    return content
             except json.JSONDecodeError:
                 pass
 
-        if not content.strip():
-            raise EmptyStreamError("流式响应内容为空")
-        return content
+        raise EmptyStreamError("流式响应内容为空")
 
 
 # ============================================================================
@@ -716,9 +783,9 @@ async def _call_tavily_extract(url: str) -> tuple[Optional[str], Optional[str]]:
     body = {"urls": [url], "format": "markdown"}
     try:
         async with httpx.AsyncClient(timeout=60.0) as client:
-            response = await client.post(endpoint, headers=headers, json=body)
-            response.raise_for_status()
-            data = response.json()
+            async with client.stream("POST", endpoint, headers=headers, json=body) as response:
+                response.raise_for_status()
+                data = await _read_json_response(response)
     except httpx.TimeoutException:
         return None, "Tavily extract 超时"
     except httpx.HTTPStatusError as e:
@@ -792,9 +859,9 @@ async def _call_tavily_search(query: str, max_results: int = 6) -> tuple[list[di
     }
     try:
         async with httpx.AsyncClient(timeout=90.0) as client:
-            response = await client.post(endpoint, headers=headers, json=body)
-            response.raise_for_status()
-            data = response.json()
+            async with client.stream("POST", endpoint, headers=headers, json=body) as response:
+                response.raise_for_status()
+                data = await _read_json_response(response)
     except httpx.TimeoutException:
         return [], "Tavily search 超时"
     except httpx.HTTPStatusError as e:
@@ -802,17 +869,29 @@ async def _call_tavily_search(query: str, max_results: int = 6) -> tuple[list[di
     except Exception as e:
         return [], f"Tavily search 错误: {str(e)}"
 
-    results = (data or {}).get("results") or []
-    if not isinstance(results, list) or not results:
-        return [], None
-    return [
-        {
-            "title": (r or {}).get("title", "") or "",
-            "url": (r or {}).get("url", "") or "",
-            "description": (r or {}).get("content", "") or "",
+    if not isinstance(data, dict):
+        return [], "Tavily search 返回无效响应"
+    results = data.get("results") or []
+    if not isinstance(results, list):
+        return [], "Tavily search 返回无效结果"
+
+    normalized = []
+    ignored = 0
+    for result in results:
+        if not isinstance(result, dict):
+            ignored += 1
+            continue
+        item = {
+            "title": result.get("title", "") or "",
+            "url": result.get("url", "") or "",
+            "description": result.get("content", "") or "",
         }
-        for r in results
-    ], None
+        if _is_valid_search_result(item):
+            normalized.append(item)
+        else:
+            ignored += 1
+    warning = f"Tavily search 忽略 {ignored} 条无效结果" if ignored else None
+    return normalized, warning
 
 
 async def _call_tavily_map(
@@ -841,18 +920,33 @@ async def _call_tavily_map(
 
     try:
         async with httpx.AsyncClient(timeout=float(timeout + 10)) as client:
-            response = await client.post(endpoint, headers=headers, json=body)
-            response.raise_for_status()
-            data = response.json()
+            async with client.stream("POST", endpoint, headers=headers, json=body) as response:
+                response.raise_for_status()
+                data = await _read_json_response(response)
+            if not isinstance(data, dict):
+                return {"error": "Tavily map 返回无效响应"}
+            if "error" in data:
+                error = data["error"]
+                return {"error": error if error else "Tavily map 返回错误响应"}
+
+            base_url = data.get("base_url")
+            results = data.get("results")
+            response_time = data.get("response_time")
+            if not isinstance(base_url, str) or not base_url.strip():
+                return {"error": "Tavily map 返回无效 base_url"}
+            if not isinstance(results, list) or any(not isinstance(item, str) for item in results):
+                return {"error": "Tavily map 返回无效 results"}
+            if isinstance(response_time, bool) or not isinstance(response_time, (int, float)):
+                return {"error": "Tavily map 返回无效 response_time"}
             return {
-                "base_url": data.get("base_url", ""),
-                "results": data.get("results", []),
-                "response_time": data.get("response_time", 0),
+                "base_url": base_url,
+                "results": results,
+                "response_time": response_time,
             }
     except httpx.TimeoutException:
         return {"error": f"映射超时: 请求超过{timeout}秒"}
     except httpx.HTTPStatusError as e:
-        return {"error": f"HTTP错误: {e.response.status_code}", "status_code": e.response.status_code, "detail": e.response.text[:200]}
+        return {"error": f"HTTP错误: {e.response.status_code}", "status_code": e.response.status_code}
     except Exception as e:
         return {"error": f"映射错误: {str(e)}"}
 
@@ -882,20 +976,46 @@ def extract_json(text: str) -> str:
     # 尝试解析为 JSON
     try:
         data = json.loads(text)
-        # 标准化字段名
-        if isinstance(data, list):
-            standardized = []
-            for item in data:
-                if isinstance(item, dict):
-                    standardized.append({
-                        "title": item.get("title", ""),
-                        "url": item.get("url", item.get("link", "")),
-                        "description": item.get("description", item.get("content", item.get("snippet", item.get("summary", ""))))
-                    })
-            return json.dumps(standardized, ensure_ascii=False, indent=2)
         return json.dumps(data, ensure_ascii=False, indent=2)
-    except json.JSONDecodeError:
-        return json.dumps({"error": "解析 JSON 失败", "raw": text[:500]}, ensure_ascii=False, indent=2)
+    except json.JSONDecodeError as error:
+        raise ValueError("解析 JSON 失败") from error
+
+
+def _validate_search_results(results: list) -> None:
+    for index, item in enumerate(results):
+        _validate_search_result(item, index + 1)
+
+
+def _validate_search_result(item, index: int = 1) -> None:
+    if not isinstance(item, dict):
+        raise ValueError(f"搜索结果 {index} 必须是对象")
+    for field in ("title", "url", "description"):
+        value = item.get(field)
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"搜索结果 {index} 缺少有效 {field}")
+    url = item["url"]
+    try:
+        parts = urlsplit(url)
+        valid_url = (
+            not re.search(r"\s", url)
+            and parts.scheme.lower() in ("http", "https")
+            and bool(parts.netloc and parts.hostname)
+            and parts.username is None
+            and parts.password is None
+        )
+        parts.port
+    except ValueError:
+        valid_url = False
+    if not valid_url:
+        raise ValueError(f"搜索结果 {index} 包含无效 URL")
+
+
+def _is_valid_search_result(item) -> bool:
+    try:
+        _validate_search_result(item)
+        return True
+    except ValueError:
+        return False
 
 
 # ============================================================================
@@ -904,7 +1024,7 @@ def extract_json(text: str) -> str:
 
 async def cmd_web_search(args):
     try:
-        effective_model = config._apply_model_suffix(args.model) if args.model else config.grok_model
+        effective_model = args.model if args.model else config.grok_model
         provider = GrokSearchProvider(config.grok_api_url, config.grok_api_key, effective_model)
         result = await provider.search(args.query, args.platform, args.min_results, args.max_results)
         if args.raw:
@@ -912,8 +1032,8 @@ async def cmd_web_search(args):
         else:
             parsed = json.loads(extract_json(result))
             if not isinstance(parsed, list):
-                print(json.dumps(parsed, ensure_ascii=False, indent=2))
-                return
+                raise ValueError("搜索响应必须是 JSON 数组")
+            _validate_search_results(parsed)
 
             merged: list[dict] = parsed
 
@@ -929,10 +1049,11 @@ async def cmd_web_search(args):
                 else:
                     extras, tavily_warning = await _call_tavily_search(args.query, extra_sources)
                     if tavily_warning:
-                        _emit_tavily_warning(f"{tavily_warning}；仅附加 Grok 搜索结果")
+                        _emit_tavily_warning(f"{tavily_warning}；保留有效搜索结果")
 
                     seen: set[str] = set()
                     out: list[dict] = []
+                    ignored_tavily = 0
                     for item in merged:
                         url = (item or {}).get("url", "")
                         if isinstance(url, str) and url:
@@ -940,9 +1061,10 @@ async def cmd_web_search(args):
                         out.append(item)
 
                     for item in extras:
-                        url = (item or {}).get("url", "")
-                        if not isinstance(url, str) or not url.startswith(("http://", "https://")):
+                        if not _is_valid_search_result(item):
+                            ignored_tavily += 1
                             continue
+                        url = item["url"]
                         if url in seen:
                             continue
                         seen.add(url)
@@ -954,8 +1076,12 @@ async def cmd_web_search(args):
                             }
                         )
 
+                    if ignored_tavily:
+                        _emit_tavily_warning(f"忽略 {ignored_tavily} 条无效 Tavily 结果")
+
                     merged = out
 
+            _validate_search_results(merged)
             print(json.dumps(merged, ensure_ascii=False, indent=2))
     except ValueError as e:
         print(json.dumps({"error": str(e)}, ensure_ascii=False), file=sys.stderr)
@@ -1037,43 +1163,54 @@ async def cmd_web_map(args):
         args.limit,
         args.timeout,
     )
-    print(json.dumps(result, ensure_ascii=False, indent=2))
     if (result or {}).get("error"):
+        print(json.dumps(result, ensure_ascii=False, indent=2), file=sys.stderr)
         sys.exit(1)
+    print(json.dumps(result, ensure_ascii=False, indent=2))
 
 
 async def cmd_get_config_info(args):
     config_info = config.get_config_info()
 
+    try:
+        api_url = config.grok_api_url
+        api_key = config.grok_api_key
+    except ValueError:
+        print(json.dumps(config_info, ensure_ascii=False, indent=2), file=sys.stderr)
+        sys.exit(1)
+
     if not args.no_test:
         test_result = {"status": "未测试", "message": "", "response_time_ms": 0}
+        connection_succeeded = False
         try:
-            api_url = config.grok_api_url
-            api_key = config.grok_api_key
             models_url = f"{api_url}/models"
 
             start_time = time.time()
             async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.get(
+                async with client.stream(
+                    "GET",
                     models_url,
                     headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-                )
-                response_time = (time.time() - start_time) * 1000
-
-                if response.status_code == 200:
-                    test_result["status"] = "✅ 连接成功"
-                    test_result["response_time_ms"] = round(response_time, 2)
-                    try:
-                        models_data = response.json()
-                        if "data" in models_data:
+                ) as response:
+                    response_time = (time.time() - start_time) * 1000
+
+                    if response.status_code == 200:
+                        try:
+                            models_data = await _read_json_response(response)
+                        except ResponseTooLargeError:
+                            raise
+                        except (json.JSONDecodeError, TypeError):
+                            models_data = None
+                        connection_succeeded = True
+                        test_result["status"] = "✅ 连接成功"
+                        test_result["response_time_ms"] = round(response_time, 2)
+                        if isinstance(models_data, dict) and isinstance(models_data.get("data"), list):
                             model_count = len(models_data["data"])
                             test_result["message"] = f"已获取 {model_count} 个模型"
                             test_result["available_models"] = [m.get("id") for m in models_data["data"] if isinstance(m, dict)]
-                    except:
-                        pass
-                else:
-                    test_result["status"] = "⚠️ 连接问题"
-                    test_result["message"] = f"HTTP {response.status_code}"
+                    else:
+                        test_result["status"] = "⚠️ 连接问题"
+                        test_result["message"] = f"HTTP {response.status_code}"
 
         except httpx.TimeoutException:
             test_result["status"] = "❌ 连接超时"
@@ -1084,67 +1221,11 @@ async def cmd_get_config_info(args):
 
         config_info["connection_test"] = test_result
 
-    print(json.dumps(config_info, ensure_ascii=False, indent=2))
-
-
-async def cmd_toggle_builtin_tools(args):
-    # 查找项目根目录
-    if args.root:
-        root = Path(args.root)
-        if not root.exists():
-            print(json.dumps({"error": f"指定的根目录不存在: {args.root}"}, ensure_ascii=False), file=sys.stderr)
+        if not connection_succeeded:
+            print(json.dumps(config_info, ensure_ascii=False, indent=2), file=sys.stderr)
             sys.exit(1)
-    else:
-        root = Path.cwd()
-        while root != root.parent and not (root / ".git").exists():
-            root = root.parent
-        if not (root / ".git").exists():
-            print(json.dumps({
-                "error": "未找到 .git 目录。使用 --root 指定项目根目录。",
-                "hint": "从 git 仓库中运行此命令，或指定 --root PATH"
-            }, ensure_ascii=False), file=sys.stderr)
-            sys.exit(1)
-
-    settings_path = root / ".agent" / "settings.json"
-    tools = ["WebFetch", "WebSearch"]
 
-    # 加载或初始化
-    if settings_path.exists():
-        with open(settings_path, 'r', encoding='utf-8') as f:
-            settings = json.load(f)
-    else:
-        settings = {"permissions": {"deny": []}}
-
-    deny = settings.setdefault("permissions", {}).setdefault("deny", [])
-    blocked = all(t in deny for t in tools)
-
-    # 执行操作
-    action = args.action.lower()
-    if action in ["on", "enable"]:
-        for t in tools:
-            if t not in deny:
-                deny.append(t)
-        settings_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(settings_path, 'w', encoding='utf-8') as f:
-            json.dump(settings, f, ensure_ascii=False, indent=2)
-        msg = "内置工具已禁用"
-        blocked = True
-    elif action in ["off", "disable"]:
-        deny[:] = [t for t in deny if t not in tools]
-        settings_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(settings_path, 'w', encoding='utf-8') as f:
-            json.dump(settings, f, ensure_ascii=False, indent=2)
-        msg = "内置工具已启用"
-        blocked = False
-    else:
-        msg = f"内置工具当前{'已禁用' if blocked else '已启用'}"
-
-    print(json.dumps({
-        "blocked": blocked,
-        "deny_list": deny,
-        "file": str(settings_path),
-        "message": msg
-    }, ensure_ascii=False, indent=2))
+    print(json.dumps(config_info, ensure_ascii=False, indent=2))
 
 
 # ============================================================================
@@ -1158,7 +1239,6 @@ async def _run_command(args):
         "web_fetch": cmd_web_fetch,
         "web_map": cmd_web_map,
         "get_config_info": cmd_get_config_info,
-        "toggle_builtin_tools": cmd_toggle_builtin_tools,
     }
     try:
         await commands[args.command](args)
@@ -1167,6 +1247,7 @@ async def _run_command(args):
 
 
 def main():
+    load_dotenv()
     parser = argparse.ArgumentParser(
         prog="groksearch_cli",
         description="GrokSearch CLI - 通过 Grok/Tavily 进行独立的网页搜索/获取/映射"
@@ -1205,11 +1286,6 @@ def main():
     p_config = subparsers.add_parser("get_config_info", help="显示配置并测试连接")
     p_config.add_argument("--no-test", action="store_true", help="跳过连接测试")
 
-    # toggle_builtin_tools
-    p_toggle = subparsers.add_parser("toggle_builtin_tools", help="切换内置 WebSearch/WebFetch")
-    p_toggle.add_argument("--action", "-a", default="status", help="操作: on/off/status")
-    p_toggle.add_argument("--root", "-r", help="项目根路径 (默认: 通过 .git 自动检测)")
-
     args = parser.parse_args()
 
     # 应用覆盖