update agent connect version

Author: chgaowei

app/tool/anp_tool.py

@@ -7,64 +7,65 @@
 
 from app.logger import logger
 from app.tool.base import BaseTool
-from app.tool.did_auth_client import DIDAuthClient
+from agent_connect.authentication import DIDWbaAuthHeader
 
 class ANPTool(BaseTool):
     name: str = "anp_tool"
-    description: str = """使用 Agent Network Protocol (ANP) 与其他智能体进行交互。
-第一次使用时，请输入 URL: https://agent-search.ai/ad.json，这是一个智能体搜索服务，可以利用里面的接口查询能够提供酒店、门票景点的智能体。
-收到智能体的描述文档后，你可以根据智能体描述文档中的数据链接URL，爬取数据。中间过程中可以调用API完成服务。知道你认为任务完成。
-注意，使用ANPTool获得的任何URL，必须使用ANPTool调用，不要自己直接调用。
+    description: str = """Use Agent Network Protocol (ANP) to interact with other agents.
+1. For the first use, please enter the URL: https://agent-search.ai/ad.json, which is an agent search service. You can use the interfaces inside to query agents that can provide hotels, tickets, and attractions.
+2. After receiving the agent's description document, you can crawl data based on the data link URL in the agent's description document.
+3. During the process, you can call the API to complete the service until you think the task is completed.
+4. Note, any URL obtained using ANPTool must be called using ANPTool, do not call it directly yourself.
 """
     parameters: dict = {
         "type": "object",
         "properties": {
             "url": {
                 "type": "string",
-                "description": "(required) 智能体描述文件或 API 端点的 URL",
+                "description": "(required) URL of the agent description file or API endpoint",
             },
             "method": {
                 "type": "string",
-                "description": "(optional) HTTP 方法，如 GET、POST、PUT 等，默认为 GET",
+                "description": "(optional) HTTP method, such as GET, POST, PUT, etc., default is GET",
                 "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"],
                 "default": "GET",
             },
             "headers": {
                 "type": "object",
-                "description": "(optional) HTTP 请求头",
+                "description": "(optional) HTTP request headers",
                 "default": {},
             },
             "params": {
                 "type": "object",
-                "description": "(optional) URL 查询参数",
+                "description": "(optional) URL query parameters",
                 "default": {},
             },
             "body": {
                 "type": "object",
-                "description": "(optional) 请求体，用于 POST/PUT 请求",
+                "description": "(optional) Request body for POST/PUT requests",
             },
         },
         "required": ["url"],
     }
 
-    # 声明 auth_client 字段
-    auth_client: Optional[DIDAuthClient] = None
+    # Declare auth_client field
+    auth_client: Optional[DIDWbaAuthHeader] = None
 
     def __init__(self, **data):
         super().__init__(**data)
 
-        # 获取当前脚本目录
+        # Get current script directory
         current_dir = Path(__file__).parent
-        # 获取项目根目录
+        # Get project root directory
         base_dir = current_dir.parent.parent
 
-        # 初始化 DID 身份验证客户端
+        # Initialize DID authentication client
         did_path = str(base_dir / "config/did_test_public_doc/did.json")
         key_path = str(base_dir / "config/did_test_public_doc/key-1_private.pem")
 
-        logger.info(f"ANPTool 初始化 - DID路径: {did_path}, 私钥路径: {key_path}")
+        logger.info(f"ANPTool initialized - DID path: {did_path}, private key path: {key_path}")
 
-        self.auth_client = DIDAuthClient(
+        self.auth_client = DIDWbaAuthHeader(
             did_document_path=did_path,
             private_key_path=key_path
         )
@@ -78,145 +79,124 @@ async def execute(
         body: Dict[str, Any] = None
     ) -> Dict[str, Any]:
         """
-        执行 HTTP 请求与其他智能体交互
+        Execute HTTP request to interact with other agents
         
         Args:
-            url (str): 智能体描述文件或 API 端点的 URL
-            method (str, optional): HTTP 方法，默认为 "GET"
-            headers (Dict[str, str], optional): HTTP 请求头
-            params (Dict[str, Any], optional): URL 查询参数
-            body (Dict[str, Any], optional): 请求体，用于 POST/PUT 请求
+            url (str): URL of the agent description file or API endpoint
+            method (str, optional): HTTP method, default is "GET"
+            headers (Dict[str, str], optional): HTTP request headers
+            params (Dict[str, Any], optional): URL query parameters
+            body (Dict[str, Any], optional): Request body for POST/PUT requests
             
         Returns:
-            Dict[str, Any]: 响应内容
+            Dict[str, Any]: Response content
         """
 
         if headers is None:
             headers = {}
         if params is None:
             params = {}
 
-        logger.info(f"ANP请求: {method} {url}")
+        logger.info(f"ANP request: {method} {url}")
 
-        # 添加基本请求头
+        # Add basic request headers
         if "Content-Type" not in headers and method in ["POST", "PUT", "PATCH"]:
             headers["Content-Type"] = "application/json"
 
-        # 添加 DID 身份验证
+        # Add DID authentication
         if self.auth_client:
             try:
                 auth_headers = self.auth_client.get_auth_header(url)
                 headers.update(auth_headers)
             except Exception as e:
-                logger.error(f"获取身份验证头失败: {str(e)}")
+                logger.error(f"Failed to get authentication header: {str(e)}")
 
 
         async with aiohttp.ClientSession() as session:
-            # 准备请求参数
+            # Prepare request parameters
             request_kwargs = {
                 "url": url,
                 "headers": headers,
                 "params": params,
             }
 
-            # 如果有请求体且方法支持，添加请求体
+            # If there is a request body and the method supports it, add the request body
             if body is not None and method in ["POST", "PUT", "PATCH"]:
                 request_kwargs["json"] = body
 
-            # 执行请求
+            # Execute request
             http_method = getattr(session, method.lower())
 
             try:
                 async with http_method(**request_kwargs) as response:
-                    logger.info(f"ANP响应: 状态码 {response.status}")
+                    logger.info(f"ANP response: status code {response.status}")
 
-                    # 检查响应状态
+                    # Check response status
                     if response.status == 401 and "Authorization" in headers and self.auth_client:
-                        logger.warning("认证失败 (401)，尝试重新获取身份验证")
-                        # 如果认证失败且使用了令牌，清除令牌并重试
+                        logger.warning("Authentication failed (401), trying to get authentication again")
+                        # If authentication fails and a token was used, clear the token and retry
                         self.auth_client.clear_token(url)
-                        # 重新获取身份验证头
+                        # Get authentication header again
                         headers.update(self.auth_client.get_auth_header(url, force_new=True))
-                        # 重新执行请求
+                        # Execute request again
                         request_kwargs["headers"] = headers
                         async with http_method(**request_kwargs) as retry_response:
-                            logger.info(f"ANP重试响应: 状态码 {retry_response.status}")
+                            logger.info(f"ANP retry response: status code {retry_response.status}")
                             return await self._process_response(retry_response, url)
 
                     return await self._process_response(response, url)
             except aiohttp.ClientError as e:
-                logger.error(f"HTTP 请求失败: {str(e)}")
+                logger.error(f"HTTP request failed: {str(e)}")
                 return {
-                    "error": f"HTTP 请求失败: {str(e)}",
+                    "error": f"HTTP request failed: {str(e)}",
                     "status_code": 500
                 }
 
 
     async def _process_response(self, response, url):
-        """处理 HTTP 响应"""
-        # 如果认证成功，更新令牌
+        """Process HTTP response"""
+        # If authentication is successful, update the token
         if response.status == 200 and self.auth_client:
             try:
                 self.auth_client.update_token(url, dict(response.headers))
             except Exception as e:
-                logger.error(f"更新令牌失败: {str(e)}")
+                logger.error(f"Failed to update token: {str(e)}")
 
-        # 获取响应内容类型
+        # Get response content type
         content_type = response.headers.get('Content-Type', '').lower()
 
-        # 获取响应文本
+        # Get response text
         text = await response.text()
 
-        # 根据内容类型处理响应
+        # Process response based on content type
         if 'application/json' in content_type:
-            # 处理 JSON 响应
+            # Process JSON response
             try:
                 result = json.loads(text)
-                logger.info("成功解析 JSON 响应")
+                logger.info("Successfully parsed JSON response")
             except json.JSONDecodeError:
-                logger.warning("Content-Type 声明为 JSON 但解析失败，返回原始文本")
+                logger.warning("Content-Type declared as JSON but parsing failed, returning raw text")
                 result = {"text": text, "format": "text", "content_type": content_type}
         elif 'application/yaml' in content_type or 'application/x-yaml' in content_type:
-            # 处理 YAML 响应
+            # Process YAML response
             try:
                 result = yaml.safe_load(text)
-                logger.info("成功解析 YAML 响应")
+                logger.info("Successfully parsed YAML response")
                 result = {"data": result, "format": "yaml", "content_type": content_type}
             except yaml.YAMLError:
-                logger.warning("Content-Type 声明为 YAML 但解析失败，返回原始文本")
+                logger.warning("Content-Type declared as YAML but parsing failed, returning raw text")
                 result = {"text": text, "format": "text", "content_type": content_type}
         else:
-            # 尝试自动检测格式
-            # 首先尝试解析为 JSON
-            try:
-                result = json.loads(text)
-                logger.info("自动检测到 JSON 格式并成功解析")
-                result = {"data": result, "format": "json", "content_type": content_type}
-            except json.JSONDecodeError:
-                # 然后尝试解析为 YAML
-                if text.strip() and (':' in text or '-' in text):  # 简单检查是否可能是 YAML
-                    try:
-                        result = yaml.safe_load(text)
-                        if isinstance(result, (dict, list)):  # 确认是结构化数据
-                            logger.info("自动检测到 YAML 格式并成功解析")
-                            result = {"data": result, "format": "yaml", "content_type": content_type}
-                        else:
-                            # 可能是纯文本但恰好符合 YAML 语法
-                            result = {"text": text, "format": "text", "content_type": content_type}
-                    except yaml.YAMLError:
-                        # 不是 YAML，返回原始文本
-                        result = {"text": text, "format": "text", "content_type": content_type}
-                else:
-                    # 不像是 YAML，返回原始文本
-                    result = {"text": text, "format": "text", "content_type": content_type}
-        
-        # 添加状态码到结果
+            # Default to text
+            result = {"text": text, "format": "text", "content_type": content_type}
+            
+        # Add status code to result
         if isinstance(result, dict):
             result["status_code"] = response.status
         else:
             result = {"data": result, "status_code": response.status, "format": "unknown", "content_type": content_type}
 
-        # 添加 URL 到结果，方便追踪
+        # Add URL to result for tracking
         result["url"] = str(url)
 
         return result