sycommon-python-lib 0.2.5a29__py3-none-any.whl → 0.2.5a31__py3-none-any.whl

sycommon/agent/sandbox/http_sandbox_backend.py

@@ -42,6 +42,11 @@ def _read_file_safe(path: str) -> bytes:
         return f.read()
 
 
+def _shell_quote(value: str) -> str:
+    """对 shell 值加单引号，防注入"""
+    return "'" + value.replace("'", "'\\''") + "'"
+
+
 def filter_instances_by_owner(instances: list, user_id: str, timeout: float = 3.0) -> list:
     """过滤掉不属于当前用户的本地沙箱实例。
 
@@ -120,6 +125,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         nacos_service_name: str = None,
         nacos_group: str = "DEFAULT_GROUP",
         token: str = None,
+        env: dict[str, str] = None,
     ):
         """
         初始化 HTTP 沙箱后端
@@ -132,6 +138,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             auto_sync: 是否在首次文件操作时自动同步（默认 False）
             nacos_service_name: Nacos 服务名（用于故障转移时重新发现服务）
             nacos_group: Nacos 服务分组
+            env: 注入到沙箱的环境变量字典，每次执行命令时自动前置 export
         """
         self._base_url = base_url.rstrip("/")
         self._user_id = user_id.lower().replace(" ", "") if user_id else user_id
@@ -143,7 +150,18 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         self._local_mode: Optional[bool] = None
 
         # Token authentication: instance-level > env var
-        self._token = token if token is not None else os.environ.get("SANDBOX_TOKEN", "")
+        self._token = token if token is not None else os.environ.get(
+            "SANDBOX_TOKEN", "")
+
+        # 沙箱环境变量注入
+        self._env = env or {}
+        self._env_prefix = ""
+        if self._env:
+            exports = " && ".join(
+                f"export {k}={_shell_quote(str(v))}"
+                for k, v in self._env.items()
+            )
+            self._env_prefix = f"{exports} && "
 
         # Nacos 配置（用于故障转移）
         self._nacos_service_name = nacos_service_name
@@ -151,7 +169,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
         # 共享异步 HTTP 会话（连接池复用，惰性初始化）
         self._async_session: Optional[aiohttp.ClientSession] = None
-        self._session_loop_id: Optional[int] = None  # track which loop created the session
+        # track which loop created the session
+        self._session_loop_id: Optional[int] = None
 
         # 生成 ID
         self._id = self._base_url.replace(
@@ -224,6 +243,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         sync_dirs: List[tuple[str, str]] = None,
         auto_sync: bool = False,
         load_balance: bool = True,
+        env: dict[str, str] = None,
     ) -> "HTTPSandboxBackend":
         """
         从 Nacos 服务发现创建后端实例
@@ -244,18 +264,21 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         Raises:
             RuntimeError: 无法发现服务实例或 NacosService 未初始化
         """
-        SYLogger.info(f"[Sandbox] from_nacos 开始: service_name={service_name}, user_id={user_id}, version={version}")
+        SYLogger.info(
+            f"[Sandbox] from_nacos 开始: service_name={service_name}, user_id={user_id}, version={version}")
 
         # 本地调试支持：读取环境变量 SANDBOX_URL，如果设置则直接使用，跳过 Nacos
         sandbox_url = os.environ.get('SANDBOX_URL', '').strip()
         if sandbox_url:
-            SYLogger.info(f"[Sandbox] 检测到 SANDBOX_URL={sandbox_url}，跳过 Nacos 直接连接")
+            SYLogger.info(
+                f"[Sandbox] 检测到 SANDBOX_URL={sandbox_url}，跳过 Nacos 直接连接")
             return cls(
                 base_url=sandbox_url,
                 user_id=user_id,
                 timeout=timeout,
                 sync_dirs=sync_dirs,
                 auto_sync=auto_sync,
+                env=env,
             )
 
         from sycommon.synacos.nacos_service import NacosService
@@ -289,7 +312,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             hash_value = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
             instance_index = hash_value % len(instances)
             instance = instances[instance_index]
-            SYLogger.info(f"[Sandbox] 负载均衡: user_id={user_id} -> instance[{instance_index}/{len(instances)}]")
+            SYLogger.info(
+                f"[Sandbox] 负载均衡: user_id={user_id} -> instance[{instance_index}/{len(instances)}]")
         else:
             instance = instances[0]
 
@@ -305,6 +329,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             auto_sync=auto_sync,
             nacos_service_name=service_name,
             nacos_group=group,
+            env=env,
         )
 
     @classmethod
@@ -318,11 +343,12 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         sync_dirs: List[tuple[str, str]] = None,
         auto_sync: bool = False,
         load_balance: bool = True,
+        env: dict[str, str] = None,
     ) -> "HTTPSandboxBackend":
         """异步从 Nacos 服务发现创建后端实例"""
         return await asyncio.to_thread(
             cls.from_nacos,
-            service_name, user_id, group, version, timeout, sync_dirs, auto_sync, load_balance,
+            service_name, user_id, group, version, timeout, sync_dirs, auto_sync, load_balance, env,
         )
 
     # ============== 内部方法 - 同步版本 ==============
@@ -351,13 +377,15 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             )
 
             if not instances:
-                SYLogger.warning(f"[Sandbox] Nacos 未发现可用服务: {self._nacos_service_name}")
+                SYLogger.warning(
+                    f"[Sandbox] Nacos 未发现可用服务: {self._nacos_service_name}")
                 return False
 
             # 过滤掉不属于当前用户的本地沙箱
             instances = filter_instances_by_owner(instances, self._user_id)
             if not instances:
-                SYLogger.warning(f"[Sandbox] 过滤后无可用服务: {self._nacos_service_name}")
+                SYLogger.warning(
+                    f"[Sandbox] 过滤后无可用服务: {self._nacos_service_name}")
                 return False
 
             instance = instances[0]
@@ -376,7 +404,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 try:
                     sync_result = self._sync_workspace_sync()
                     workspace_files = sync_result.get("files", [])
-                    SYLogger.info(f"[Sandbox] 从旧服务获取 {len(workspace_files)} 个工作空间文件")
+                    SYLogger.info(
+                        f"[Sandbox] 从旧服务获取 {len(workspace_files)} 个工作空间文件")
                 except Exception as e:
                     SYLogger.warning(f"[Sandbox] 获取工作空间文件失败: {e}")
 
@@ -391,9 +420,12 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
                 # 4. 上传工作空间文件到新服务
                 if workspace_files:
-                    SYLogger.info(f"[Sandbox] 上传 {len(workspace_files)} 个工作空间文件到新服务...")
-                    upload_result = self._upload_workspace_files_sync(workspace_files)
-                    SYLogger.info(f"[Sandbox] 工作空间迁移完成: 成功 {upload_result['success']}, 失败 {upload_result['failed']}")
+                    SYLogger.info(
+                        f"[Sandbox] 上传 {len(workspace_files)} 个工作空间文件到新服务...")
+                    upload_result = self._upload_workspace_files_sync(
+                        workspace_files)
+                    SYLogger.info(
+                        f"[Sandbox] 工作空间迁移完成: 成功 {upload_result['success']}, 失败 {upload_result['failed']}")
 
                 SYLogger.info(f"[Sandbox] 服务切换完成: {old_url} -> {new_url}")
                 return True
@@ -431,11 +463,13 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         headers = self._build_headers()
 
         url = f"{self._base_url}{endpoint}"
-        SYLogger.info(f"[Sandbox] POST 请求开始: {url}, timeout={http_timeout}s, command_timeout={actual_timeout}s")
+        SYLogger.info(
+            f"[Sandbox] POST 请求开始: {url}, timeout={http_timeout}s, command_timeout={actual_timeout}s")
 
         for attempt in range(max_retries):
             try:
-                SYLogger.info(f"[Sandbox] POST 尝试 {attempt + 1}/{max_retries}: {url}")
+                SYLogger.info(
+                    f"[Sandbox] POST 尝试 {attempt + 1}/{max_retries}: {url}")
                 resp = requests.post(
                     url,
                     json=data,
@@ -444,14 +478,16 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 )
                 SYLogger.info(f"[Sandbox] POST 响应状态码: {resp.status_code}")
                 if resp.status_code >= 400:
-                    SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status_code}: {resp.text}")
+                    SYLogger.error(
+                        f"[Sandbox] HTTP 错误 {resp.status_code}: {resp.text}")
                     resp.raise_for_status()
                 result = resp.json()
                 SYLogger.info(f"[Sandbox] POST 成功: {url}")
                 return result
 
             except (requests.exceptions.RequestException, requests.exceptions.HTTPError) as e:
-                SYLogger.warning(f"[Sandbox] 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
+                SYLogger.warning(
+                    f"[Sandbox] 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
                     backoff = 2 ** attempt
@@ -481,7 +517,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         headers = self._build_headers()
 
         url = f"{self._base_url}{endpoint}"
-        SYLogger.info(f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
+        SYLogger.info(
+            f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
 
         timeout_obj = aiohttp.ClientTimeout(total=http_timeout)
         session = await self._get_async_session()
@@ -509,7 +546,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             try:
                 return await self._post_async(endpoint, data, timeout)
             except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-                SYLogger.warning(f"[Sandbox] Async 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
+                SYLogger.warning(
+                    f"[Sandbox] Async 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
                     # 指数退避: 1s, 2s
@@ -553,7 +591,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         env_workspace = os.environ.get("SANDBOX_WORKSPACE")
         if env_workspace:
             self._workspace_root = env_workspace
-            SYLogger.info(f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
+            SYLogger.info(
+                f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
             return self._workspace_root
 
         # 从沙箱服务端 health 接口获取
@@ -564,14 +603,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 workspace = resp.json().get("workspace", "")
                 if workspace:
                     self._workspace_root = workspace
-                    SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
+                    SYLogger.info(
+                        f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
                     return self._workspace_root
         except Exception as e:
             SYLogger.warning(f"[Sandbox] 获取沙箱 workspace 失败: {e}")
 
         # 兜底：根据平台猜测
-        self._workspace_root = "/data/sycommon_sandbox" if sys.platform != "darwin" and sys.platform != "win32" else os.path.join(tempfile.gettempdir(), "sycommon_sandbox")
-        SYLogger.warning(f"[Sandbox] 无法获取沙箱 workspace，使用兜底值: {self._workspace_root}")
+        self._workspace_root = "/data/sycommon_sandbox" if sys.platform != "darwin" and sys.platform != "win32" else os.path.join(
+            tempfile.gettempdir(), "sycommon_sandbox")
+        SYLogger.warning(
+            f"[Sandbox] 无法获取沙箱 workspace，使用兜底值: {self._workspace_root}")
         return self._workspace_root
 
     async def _aresolve_workspace_root(self) -> str:
@@ -583,7 +625,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         env_workspace = os.environ.get("SANDBOX_WORKSPACE")
         if env_workspace:
             self._workspace_root = env_workspace
-            SYLogger.info(f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
+            SYLogger.info(
+                f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
             return self._workspace_root
 
         # 从沙箱服务端 health 接口获取（使用共享连接池）
@@ -597,20 +640,42 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     workspace = data.get("workspace", "")
                     if workspace:
                         self._workspace_root = workspace
-                        SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
+                        SYLogger.info(
+                            f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
                         return self._workspace_root
         except Exception as e:
             SYLogger.warning(f"[Sandbox] 异步获取沙箱 workspace 失败: {e}")
 
         # 兜底
-        self._workspace_root = "/data/sycommon_sandbox" if sys.platform != "darwin" and sys.platform != "win32" else os.path.join(tempfile.gettempdir(), "sycommon_sandbox")
-        SYLogger.warning(f"[Sandbox] 无法获取沙箱 workspace，使用兜底值: {self._workspace_root}")
+        self._workspace_root = "/data/sycommon_sandbox" if sys.platform != "darwin" and sys.platform != "win32" else os.path.join(
+            tempfile.gettempdir(), "sycommon_sandbox")
+        SYLogger.warning(
+            f"[Sandbox] 无法获取沙箱 workspace，使用兜底值: {self._workspace_root}")
         return self._workspace_root
 
     # ============== 执行命令 ==============
 
+    def update_env(self, env_updates: dict[str, str]):
+        """动态更新沙箱环境变量（合并到现有 env，重建 _env_prefix）
+
+        用于运行时刷新 token 等场景，无需重建整个沙箱实例。
+        """
+        self._env.update(env_updates)
+        exports = " && ".join(
+            f"export {k}={_shell_quote(str(v))}"
+            for k, v in self._env.items()
+        )
+        self._env_prefix = f"{exports} && " if exports else ""
+
+    def _inject_env(self, command: str) -> str:
+        """在命令前注入环境变量 export"""
+        if self._env_prefix:
+            return f"{self._env_prefix}{command}"
+        return command
+
     def execute(self, command: str, *, timeout: int = None) -> ExecuteResponse:
         """执行 shell 命令（服务端负责路径隔离和目录初始化）"""
+        command = self._inject_env(command)
         SYLogger.info(f"[Sandbox] execute 开始: command={command}")
         self._ensure_synced_sync()
         SYLogger.info(f"[Sandbox] _ensure_synced_sync 完成，开始执行命令: {command}")
@@ -625,7 +690,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 exit_code=result["exit_code"],
                 truncated=result.get("truncated", False)
             )
-            SYLogger.info(f"[Sandbox] 执行完成: exit_code={response.exit_code}, output={response.output[:500] if response.output else 'None'}...")
+            SYLogger.info(
+                f"[Sandbox] 执行完成: exit_code={response.exit_code}, output={response.output[:500] if response.output else 'None'}...")
             return response
         except Exception as e:
             SYLogger.error(f"[Sandbox] 执行异常: {e}")
@@ -637,6 +703,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
     async def aexecute(self, command: str, *, timeout: int = None) -> ExecuteResponse:
         """异步执行 shell 命令（服务端负责路径隔离和目录初始化）"""
+        command = self._inject_env(command)
         SYLogger.info(f"[Sandbox] aexecute 开始: command={command}")
         await self._ensure_synced_async()
         SYLogger.info(f"[Sandbox] _ensure_synced_async 完成，开始执行命令: {command}")
@@ -672,12 +739,14 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             SYLogger.info("[Sandbox] 没有配置同步目录")
             return {}
 
-        SYLogger.info(f"[Sandbox] _sync_async 开始, 共 {len(self._sync_dirs)} 个目录")
+        SYLogger.info(
+            f"[Sandbox] _sync_async 开始, 共 {len(self._sync_dirs)} 个目录")
         results = {}
         for idx, entry in enumerate(self._sync_dirs):
             local_path, remote_path = entry[0], entry[1]
             mode = entry[2] if len(entry) > 2 else "full"
-            SYLogger.info(f"[Sandbox] 同步目录 [{idx+1}/{len(self._sync_dirs)}]: {local_path} -> {remote_path} (mode={mode})")
+            SYLogger.info(
+                f"[Sandbox] 同步目录 [{idx+1}/{len(self._sync_dirs)}]: {local_path} -> {remote_path} (mode={mode})")
             local_dir = Path(local_path)
 
             def _check_path(ld=local_dir):
@@ -686,23 +755,27 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             exists, is_dir = await asyncio.to_thread(_check_path)
             if not exists:
                 SYLogger.error(f"[Sandbox] 本地目录不存在: {local_path}")
-                results[local_path] = {"success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
+                results[local_path] = {
+                    "success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
                 continue
 
             if is_dir:
                 SYLogger.info(f"[Sandbox] 开始上传目录: {local_path}")
                 result = await self._upload_directory_async(str(local_dir), remote_path, mode=mode, timeout=timeout)
                 results[local_path] = result
-                SYLogger.info(f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
+                SYLogger.info(
+                    f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 # 单文件
                 SYLogger.info(f"[Sandbox] 上传单文件: {local_path}")
                 content = await asyncio.to_thread(lambda p: _read_file_safe(p), local_dir)
                 upload_results = await self.aupload_files([(remote_path, content)], timeout=timeout)
                 if upload_results[0].error:
-                    results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
+                    results[local_path] = {"success": 0, "failed": 1, "errors": [
+                        {"path": remote_path, "error": upload_results[0].error}]}
                 else:
-                    results[local_path] = {"success": 1, "failed": 0, "errors": []}
+                    results[local_path] = {
+                        "success": 1, "failed": 0, "errors": []}
 
         self._synced = True
         SYLogger.info("[Sandbox] _sync_async 完成")
@@ -728,7 +801,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
         await asyncio.to_thread(_check)
 
-        SYLogger.info(f"[Sandbox] _upload_directory_async 开始: {local_dir} -> {remote_path} (mode={mode})")
+        SYLogger.info(
+            f"[Sandbox] _upload_directory_async 开始: {local_dir} -> {remote_path} (mode={mode})")
 
         # partial 模式：查询沙箱已有子目录并跳过
         existing_subdirs = set()
@@ -743,11 +817,13 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                         if item.get("is_dir", False):
                             existing_subdirs.add(item.get("name", ""))
                     if existing_subdirs:
-                        SYLogger.info(f"[Sandbox] partial 模式，跳过已有子目录: {existing_subdirs}")
+                        SYLogger.info(
+                            f"[Sandbox] partial 模式，跳过已有子目录: {existing_subdirs}")
             except Exception as e:
                 SYLogger.warning(f"[Sandbox] 查询沙箱目录失败，将全量同步: {e}")
 
-        exclude_patterns = [".git", "__pycache__", ".pyc", ".DS_Store", "node_modules"]
+        exclude_patterns = [".git", "__pycache__",
+                            ".pyc", ".DS_Store", "node_modules"]
 
         def should_exclude(name: str) -> bool:
             for pattern in exclude_patterns:
@@ -768,7 +844,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     try:
                         rel = Path(root).relative_to(local_path)
                         if str(rel) == ".":
-                            dirs[:] = [d for d in dirs if d not in existing_subdirs]
+                            dirs[:] = [
+                                d for d in dirs if d not in existing_subdirs]
                     except ValueError:
                         pass
 
@@ -810,15 +887,18 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             upload_results = await self.aupload_files(batch_items, timeout=timeout)
             for r in upload_results:
                 if r.error:
-                    all_results.append({"ok": False, "path": r.path, "error": r.error})
+                    all_results.append(
+                        {"ok": False, "path": r.path, "error": r.error})
                 else:
                     all_results.append({"ok": True})
 
         success_count = sum(1 for r in all_results if r["ok"])
         failed_count = sum(1 for r in all_results if not r["ok"])
-        errors = [{"path": r["path"], "error": r["error"]} for r in all_results if not r["ok"]]
+        errors = [{"path": r["path"], "error": r["error"]}
+                  for r in all_results if not r["ok"]]
 
-        SYLogger.info(f"[Sandbox] _upload_directory_async 完成: 成功={success_count}, 失败={failed_count}")
+        SYLogger.info(
+            f"[Sandbox] _upload_directory_async 完成: 成功={success_count}, 失败={failed_count}")
         return {"success": success_count, "failed": failed_count, "errors": errors}
 
     # ============== 批量操作 ==============
@@ -855,7 +935,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 "user_id": self._user_id
             }, timeout=timeout)
             return [
-                FileUploadResponse(path=r.get("path", ""), error=r.get("error"))
+                FileUploadResponse(path=r.get("path", ""),
+                                   error=r.get("error"))
                 for r in result.get("results", [])
             ]
         except Exception as e:
@@ -868,9 +949,11 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                         "content": base64.b64encode(content).decode(),
                         "user_id": self._user_id
                     }, timeout=timeout)
-                    results.append(FileUploadResponse(path=r["path"], error=r.get("error")))
+                    results.append(FileUploadResponse(
+                        path=r["path"], error=r.get("error")))
                 except Exception as ex:
-                    results.append(FileUploadResponse(path=path, error=str(ex)))
+                    results.append(FileUploadResponse(
+                        path=path, error=str(ex)))
             return results
 
     def download_files(self, paths: List[str]) -> List[FileDownloadResponse]:
@@ -889,7 +972,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     ))
                 else:
                     content = base64.b64decode(result["content"])
-                    results.append(FileDownloadResponse(path=path, content=content))
+                    results.append(FileDownloadResponse(
+                        path=path, content=content))
             except Exception as e:
                 results.append(FileDownloadResponse(path=path, error=str(e)))
         return results
@@ -911,7 +995,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     ))
                 else:
                     content = base64.b64decode(result["content"])
-                    results.append(FileDownloadResponse(path=path, content=content))
+                    results.append(FileDownloadResponse(
+                        path=path, content=content))
             except Exception as e:
                 results.append(FileDownloadResponse(path=path, error=str(e)))
         return results
@@ -929,19 +1014,23 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         for idx, entry in enumerate(self._sync_dirs):
             local_path, remote_path = entry[0], entry[1]
             mode = entry[2] if len(entry) > 2 else "full"
-            SYLogger.info(f"[Sandbox] 同步目录 [{idx+1}/{len(self._sync_dirs)}]: {local_path} -> {remote_path} (mode={mode})")
+            SYLogger.info(
+                f"[Sandbox] 同步目录 [{idx+1}/{len(self._sync_dirs)}]: {local_path} -> {remote_path} (mode={mode})")
             local_dir = Path(local_path)
 
             if not local_dir.exists():
                 SYLogger.error(f"[Sandbox] 本地目录不存在: {local_path}")
-                results[local_path] = {"success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
+                results[local_path] = {
+                    "success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
                 continue
 
             if local_dir.is_dir():
                 SYLogger.info(f"[Sandbox] 开始上传目录: {local_path}")
-                result = self._upload_directory_sync(str(local_dir), remote_path, mode=mode)
+                result = self._upload_directory_sync(
+                    str(local_dir), remote_path, mode=mode)
                 results[local_path] = result
-                SYLogger.info(f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
+                SYLogger.info(
+                    f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 # 单文件
                 SYLogger.info(f"[Sandbox] 上传单文件: {local_path}")
@@ -949,9 +1038,11 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     content = f.read()
                 upload_results = self.upload_files([(remote_path, content)])
                 if upload_results[0].error:
-                    results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
+                    results[local_path] = {"success": 0, "failed": 1, "errors": [
+                        {"path": remote_path, "error": upload_results[0].error}]}
                 else:
-                    results[local_path] = {"success": 1, "failed": 0, "errors": []}
+                    results[local_path] = {
+                        "success": 1, "failed": 0, "errors": []}
 
         self._synced = True
         SYLogger.info("[Sandbox] _sync_sync 完成")
@@ -985,19 +1076,23 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         SYLogger.info(f"[Sandbox] sync_dirs 开始, 共 {len(dirs)} 个目录")
         results = {}
         for idx, (local_path, remote_path) in enumerate(dirs):
-            SYLogger.info(f"[Sandbox] 同步目录 [{idx+1}/{len(dirs)}]: {local_path} -> {remote_path}")
+            SYLogger.info(
+                f"[Sandbox] 同步目录 [{idx+1}/{len(dirs)}]: {local_path} -> {remote_path}")
             local_dir = Path(local_path)
 
             if not local_dir.exists():
                 SYLogger.warning(f"[Sandbox] 本地目录不存在: {local_path}")
-                results[local_path] = {"success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
+                results[local_path] = {
+                    "success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
                 continue
 
             if local_dir.is_dir():
                 SYLogger.info(f"[Sandbox] 开始上传目录: {local_path}")
-                result = self._upload_directory_sync(str(local_dir), remote_path)
+                result = self._upload_directory_sync(
+                    str(local_dir), remote_path)
                 results[local_path] = result
-                SYLogger.info(f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
+                SYLogger.info(
+                    f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 # 单文件
                 SYLogger.info(f"[Sandbox] 上传单文件: {local_path}")
@@ -1005,9 +1100,11 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     content = f.read()
                 upload_results = self.upload_files([(remote_path, content)])
                 if upload_results[0].error:
-                    results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
+                    results[local_path] = {"success": 0, "failed": 1, "errors": [
+                        {"path": remote_path, "error": upload_results[0].error}]}
                 else:
-                    results[local_path] = {"success": 1, "failed": 0, "errors": []}
+                    results[local_path] = {
+                        "success": 1, "failed": 0, "errors": []}
 
         SYLogger.info("[Sandbox] sync_dirs 完成")
         return results
@@ -1028,7 +1125,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         SYLogger.info(f"[Sandbox] async_sync_dirs 开始, 共 {len(dirs)} 个目录")
         results = {}
         for idx, (local_path, remote_path) in enumerate(dirs):
-            SYLogger.info(f"[Sandbox] 异步同步目录 [{idx+1}/{len(dirs)}]: {local_path} -> {remote_path}")
+            SYLogger.info(
+                f"[Sandbox] 异步同步目录 [{idx+1}/{len(dirs)}]: {local_path} -> {remote_path}")
             local_dir = Path(local_path)
 
             def _check_path(ld=local_dir):
@@ -1037,22 +1135,26 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             exists, is_dir = await asyncio.to_thread(_check_path)
             if not exists:
                 SYLogger.warning(f"[Sandbox] 本地目录不存在: {local_path}")
-                results[local_path] = {"success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
+                results[local_path] = {
+                    "success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
                 continue
 
             if is_dir:
                 SYLogger.info(f"[Sandbox] 开始异步上传目录: {local_path}")
                 result = await self._upload_directory_async(str(local_dir), remote_path, timeout=timeout)
                 results[local_path] = result
-                SYLogger.info(f"[Sandbox] 异步目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
+                SYLogger.info(
+                    f"[Sandbox] 异步目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 SYLogger.info(f"[Sandbox] 异步上传单文件: {local_path}")
                 content = await asyncio.to_thread(lambda p: _read_file_safe(p), local_dir)
                 upload_results = await self.aupload_files([(remote_path, content)], timeout=timeout)
                 if upload_results[0].error:
-                    results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
+                    results[local_path] = {"success": 0, "failed": 1, "errors": [
+                        {"path": remote_path, "error": upload_results[0].error}]}
                 else:
-                    results[local_path] = {"success": 1, "failed": 0, "errors": []}
+                    results[local_path] = {
+                        "success": 1, "failed": 0, "errors": []}
 
         SYLogger.info("[Sandbox] async_sync_dirs 完成")
         return results
@@ -1077,7 +1179,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         if not local_path.is_dir():
             raise NotADirectoryError(f"路径不是目录: {local_dir}")
 
-        SYLogger.info(f"[Sandbox] _upload_directory_sync 开始: {local_dir} -> {remote_path} (mode={mode})")
+        SYLogger.info(
+            f"[Sandbox] _upload_directory_sync 开始: {local_dir} -> {remote_path} (mode={mode})")
 
         # partial 模式：查询沙箱已有子目录并跳过
         existing_subdirs = set()
@@ -1092,11 +1195,13 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                         if item.get("is_dir", False):
                             existing_subdirs.add(item.get("name", ""))
                     if existing_subdirs:
-                        SYLogger.info(f"[Sandbox] partial 模式，跳过已有子目录: {existing_subdirs}")
+                        SYLogger.info(
+                            f"[Sandbox] partial 模式，跳过已有子目录: {existing_subdirs}")
             except Exception as e:
                 SYLogger.warning(f"[Sandbox] 查询沙箱目录失败，将全量同步: {e}")
 
-        exclude_patterns = [".git", "__pycache__", ".pyc", ".DS_Store", "node_modules"]
+        exclude_patterns = [".git", "__pycache__",
+                            ".pyc", ".DS_Store", "node_modules"]
 
         def should_exclude(name: str) -> bool:
             for pattern in exclude_patterns:
@@ -1117,7 +1222,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 try:
                     rel = Path(root).relative_to(local_path)
                     if str(rel) == ".":
-                        skipped_names = [d for d in dirs if d in existing_subdirs]
+                        skipped_names = [
+                            d for d in dirs if d in existing_subdirs]
                         dirs[:] = [d for d in dirs if d not in existing_subdirs]
                         if skipped_names:
                             SYLogger.info(f"[Sandbox] 跳过已有目录: {skipped_names}")
@@ -1157,7 +1263,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 if result.get("error"):
                     with lock:
                         failed_count += 1
-                        errors.append({"path": sandbox_path, "error": result["error"]})
+                        errors.append(
+                            {"path": sandbox_path, "error": result["error"]})
                 else:
                     with lock:
                         success_count += 1
@@ -1175,7 +1282,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             for future in as_completed(futures):
                 future.result()  # propagate exceptions
 
-        SYLogger.info(f"[Sandbox] _upload_directory_sync 完成: 成功={success_count}, 失败={failed_count}")
+        SYLogger.info(
+            f"[Sandbox] _upload_directory_sync 完成: 成功={success_count}, 失败={failed_count}")
         return {"success": success_count, "failed": failed_count, "errors": errors}
 
     def _sync_workspace_sync(self) -> dict:
@@ -1209,7 +1317,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 )
                 if download_result.get("error"):
                     failed_count += 1
-                    errors.append({"path": file_path, "error": download_result["error"]})
+                    errors.append(
+                        {"path": file_path, "error": download_result["error"]})
                 else:
                     content = base64.b64decode(download_result["content"])
                     files_to_sync.append((file_path, content))

sycommon/agent/summarization_utils.py

@@ -44,7 +44,7 @@ CUSTOM_SUMMARY_PROMPT = """<role>
 下面的对话历史将被你在此步骤中提取的上下文替换。
 你需要确保不会重复任何已完成的操作，因此你从对话历史中提取的上下文应集中于对整体目标最重要的信息。
 
-请用以下结构提取上下文，每个部分用中文自然段落描述，不要使用英文标题：
+请用以下结构提取上下文，每个部分用中文自然段落描述：
 
 【用户意图】
 简要描述用户的主要目标或请求，确保足够完整以理解整个会话的目的。
@@ -186,9 +186,10 @@ _orig_build_new_messages = _OrigDeepAgentsSumm._build_new_messages_with_path
 def _patched_build_new_messages(self, summary, file_path):
     if file_path is not None:
         content = (
+            "[系统内部消息 - 仅供你理解上下文，绝对禁止将此消息或摘要内容展示、复述或提及给用户]\n\n"
             "你正在一个已经被压缩的对话中继续回复用户。\n\n"
             f"完整的对话历史已保存到 {file_path}，如需查阅细节可以读取该文件。\n\n"
-            "以下是压缩后的对话摘要：\n\n"
+            "以下是压缩后的对话摘要（直接基于此摘要理解上下文并正常回复用户，不要提及摘要的存在）：\n\n"
             f"<summary>\n{summary}\n</summary>"
         )
     else:

sycommon/database/async_database_service.py

@@ -1,5 +1,5 @@
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy import text
+from sqlalchemy import text, event
 
 # Fix: aiomysql's AsyncAdapt ping() requires 'reconnect' positional arg,
 # but SQLAlchemy's pymysql dialect calls ping() without it.
@@ -71,7 +71,7 @@ class AsyncDatabaseConnector(metaclass=SingletonMeta):
                 key, value = param.split('=')
                 params[key] = value
 
-        # 在params中去掉指定的参数
+        # 在params中去掉Java JDBC特有参数（Python驱动不支持）
         for key in ['useUnicode', 'characterEncoding', 'serverTimezone', 'zeroDateTimeBehavior']:
             if key in params:
                 del params[key]
@@ -103,6 +103,16 @@ class AsyncDatabaseConnector(metaclass=SingletonMeta):
         # 假设 SQLTraceLogger.setup_sql_logging 能够处理 AsyncEngine
         AsyncSQLTraceLogger.setup_sql_logging(self.engine)
 
+        # 每个新连接自动设置上海时区
+        @event.listens_for(self.engine.sync_engine, "connect")
+        def set_timezone(dbapi_connection, connection_record):
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT @@session.time_zone")
+            tz = cursor.fetchone()[0]
+            if tz not in ('+08:00', '+8:00', 'Asia/Shanghai'):
+                cursor.execute("SET time_zone = '+8:00'")
+            cursor.close()
+
     async def test_connection(self):
         try:
             # 异步上下文管理器

sycommon/database/database_service.py

@@ -1,4 +1,4 @@
-from sqlalchemy import create_engine, text
+from sqlalchemy import create_engine, text, event
 
 from sycommon.config.Config import SingletonMeta
 from sycommon.config.DatabaseConfig import DatabaseConfig, convert_dict_keys
@@ -57,7 +57,7 @@ class DatabaseConnector(metaclass=SingletonMeta):
                 key, value = param.split('=')
                 params[key] = value
 
-        # 在params中去掉指定的参数
+        # 在params中去掉Java JDBC特有参数（Python驱动不支持）
         for key in ['useUnicode', 'characterEncoding', 'serverTimezone', 'zeroDateTimeBehavior']:
             if key in params:
                 del params[key]
@@ -84,6 +84,16 @@ class DatabaseConnector(metaclass=SingletonMeta):
         # 注册 SQL 日志拦截器
         SQLTraceLogger.setup_sql_logging(self.engine)
 
+        # 每个新连接自动设置上海时区
+        @event.listens_for(self.engine, "connect")
+        def set_timezone(dbapi_connection, connection_record):
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT @@session.time_zone")
+            tz = cursor.fetchone()[0]
+            if tz not in ('+08:00', '+8:00', 'Asia/Shanghai'):
+                cursor.execute("SET time_zone = '+8:00'")
+            cursor.close()
+
         # 测试
         if not self.test_connection():
             raise Exception("Database connection test failed")

sycommon/logging/kafka_log.py

@@ -166,15 +166,19 @@ class KafkaSink:
 
     def close(self):
         """关闭 KafkaProducer，释放连接池资源"""
-        if self._producer:
-            self._producer = None
-            try:
-                self._producer_obj.flush(timeout=5)
-                self._producer_obj.close(timeout=10)
-            except KeyboardInterrupt:
-                pass
-            except Exception:
-                pass
+        if self._producer_obj is None:
+            return
+        # 先移除引用，阻止 write() 继续发送新消息
+        self._producer = None
+        try:
+            self._producer_obj.flush(timeout=5)
+            self._producer_obj.close(timeout=10)
+        except KeyboardInterrupt:
+            pass
+        except Exception:
+            pass
+        finally:
+            self._producer_obj = None
 
 
 class _InterceptHandler(logging.Handler):

sycommon/middleware/tool_result_truncation.py

@@ -105,23 +105,34 @@ def _create_head_tail_preview(
 def _convert_list_content_to_str(content: list, tool_name: str) -> str:
     """将 list 类型的 ToolMessage.content 转换为字符串。
 
-    对于图片类型（type=image 且含 base64），转换为提示模型自行用 execute 处理的说明。
+    对于非 text 类型的 content block（image/file/audio/video 等），
+    转换为文本描述，防止上游 API 返回 type 类型错误。
     对于文本类型，保留完整文本。
     """
     parts = []
     for item in content:
         if isinstance(item, dict):
             item_type = item.get("type", "text")
-            if item_type == "image" and "base64" in item:
+            if item_type == "text" and "text" in item:
+                parts.append(item["text"])
+            elif item_type == "image" and "base64" in item:
                 b64 = item["base64"]
                 mime = item.get("mime_type", "image/unknown")
-                size_kb = len(b64) * 3 // 4 // 1024  # base64 -> bytes -> KB
+                size_kb = len(b64) * 3 // 4 // 1024
                 parts.append(
                     f"[图片文件 ({mime}, {size_kb}KB) — "
-                    f"图片二进制数据无法直接发送给模型。"
+                    f"图片二进制内容已省略。"
                     f"请使用 execute 工具通过 Python (如 PIL/OpenCV) 读取并处理图片，"
                     f"例如 OCR 识别文字、分析图片内容等。]"
                 )
+            elif "base64" in item:
+                mime = item.get("mime_type", "application/octet-stream")
+                size_kb = len(item["base64"]) * 3 // 4 // 1024
+                parts.append(
+                    f"[{item_type}文件 ({mime}, {size_kb}KB) — "
+                    f"二进制文件内容已省略。"
+                    f"请使用 execute 工具通过 Python 处理该文件。]"
+                )
             elif "text" in item:
                 parts.append(item["text"])
             else:
@@ -219,17 +230,18 @@ class ToolResultTruncationMiddleware(AgentMiddleware):
 
         content = result.content
 
-        # list 类型 content：如 read_file 读取图片返回的 base64 数据
-        # 转换为字符串描述，防止上游 API 拒绝 list content
+        # list 类型 content：如 read_file 读取非文本文件返回的 content_blocks
+        # 只要含有非 text 类型的 block，就转换为字符串描述
+        # 防止上游 API 拒绝 type=file/image/audio 等 content block
         if isinstance(content, list):
-            has_image = any(
-                isinstance(item, dict) and item.get("type") == "image" and "base64" in item
+            has_non_text = any(
+                isinstance(item, dict) and item.get("type") != "text"
                 for item in content
             )
-            if has_image:
+            if has_non_text:
                 new_content = _convert_list_content_to_str(content, tool_name)
                 SYLogger.info(
-                    f"[ToolResultTruncation] tool='{tool_name}' converted image "
+                    f"[ToolResultTruncation] tool='{tool_name}' converted "
                     f"list content to string ({len(new_content)} chars)")
                 return ToolMessage(
                     content=new_content,

sycommon/middleware/traceid.py

@@ -250,25 +250,20 @@ def setup_trace_id_handler(app):
 
             # 构建响应日志
             response_log_body = response_body.decode('utf-8', errors='ignore')
-            total_len = len(response_log_body)
-            # 检测是否包含 base64 二进制内容（如 PDF、图片等）
-            is_binary_response = False
+            # 检测是否包含 base64 二进制内容（如 PDF、图片等），如有则省略
             try:
                 resp_json = json.loads(response_log_body)
                 if isinstance(resp_json, dict) and resp_json.get("content") and len(str(resp_json["content"])) > 1000:
                     resp_json["content"] = f"... (base64/binary content omitted, {len(str(resp_json['content']))} chars)"
                     response_log_body = json.dumps(resp_json, ensure_ascii=False)
-                    is_binary_response = True
             except (json.JSONDecodeError, ValueError):
                 pass
-            if not is_binary_response and total_len > 10000:
-                response_log_body = response_log_body[:10000] + f"... (truncated, total {total_len} bytes)"
             response_message = {
                 "traceId": trace_id,
                 "status_code": response.status_code,
                 "response_body": response_log_body,
             }
-            SYLogger.info(json.dumps(response_message, ensure_ascii=False))
+            SYLogger.info(response_message)
 
             # 兜底：确保 Header 必有 TraceId
             try:

{sycommon_python_lib-0.2.5a29.dist-info → sycommon_python_lib-0.2.5a31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a29
+Version: 0.2.5a31
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.5a29.dist-info → sycommon_python_lib-0.2.5a31.dist-info}/RECORD

@@ -131,13 +131,13 @@ sycommon/agent/agent_manager.py,sha256=UhhaekEumT7g4v_Z1UB4jTp13X0n8M8erYaQdkGGW
 sycommon/agent/chat_events.py,sha256=t7qWa6OrIWLfqtd1AnqaVP67QWkn1JxpCBTZYQpoLuM,14226
 sycommon/agent/deep_agent.py,sha256=zZRmjEYAEx8LgnDCRFf6QS9Xxyy67WSzomjdC2I732Q,55405
 sycommon/agent/multi_agent_team.py,sha256=W5gP6sWIYhhXf6iBLHfyTIs9eAhUdkWrn_PF6W2cESs,26059
-sycommon/agent/summarization_utils.py,sha256=q45O-a3_H21Pm1vSIskSK0VCoheilGX5ONnC9Q7PUBE,10682
+sycommon/agent/summarization_utils.py,sha256=5eiLtxRZKTzO0tnr8sVaL-H3a0eUtvXpCa28Jw_j2eE,10889
 sycommon/agent/mcp/__init__.py,sha256=iKrdDhIrFsNIkqG_kgcwNe-nOiM6uVfolKv44LfQ-FQ,636
 sycommon/agent/mcp/models.py,sha256=zda4ho-UTYOJ5oPAZPZ-vxhfDRLghUCsMroHnA2A2QQ,1490
 sycommon/agent/mcp/tool_loader.py,sha256=iJkKSBClm348xeQ0CmK4lOUbLEQ-CRr-GvJdPmSHg9o,9916
 sycommon/agent/sandbox/__init__.py,sha256=jR7LlkD4J4Y6QYyRXQClkwmqDBCCPmycV_hQV9p9YHw,4621
 sycommon/agent/sandbox/file_ops.py,sha256=C1_gfarr2aHstaB9VzV_APJYgQtRfUVvkc3b7QIgmc0,24690
-sycommon/agent/sandbox/http_sandbox_backend.py,sha256=Mn50y5b-hfrQPX7Q6bvZfqv_PnKdad49PyE4B7DDQ7g,56297
+sycommon/agent/sandbox/http_sandbox_backend.py,sha256=_l7guM-sv4XduE9NTNVLPyRTjZZIGR4qefJUTc8e5q4,59199
 sycommon/agent/sandbox/minio_sync.py,sha256=d1kuWllvyAvAMsFZCP0OdHEQtXN9BEIgHbupC31BjSk,20000
 sycommon/agent/sandbox/sandbox_pool.py,sha256=eMn8sLakCWf90l6ni2-333QM8oBdX1CflV-WzneFp_k,9133
 sycommon/agent/sandbox/sandbox_recovery.py,sha256=X-eDODx1tmGMh_iTngV6e1ppfDBHpTdkPreJusN5MHY,7358
@@ -162,9 +162,9 @@ sycommon/config/SentryConfig.py,sha256=OsLb3G9lTsCSZ7tWkcXWJHmvfILQopBxje5pjnkFJ
 sycommon/config/XxlJobConfig.py,sha256=VSG6dn9ysfUVunOs7PqugyZUGJWmX_cEePz2ZCfqHtU,392
 sycommon/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/database/async_base_db_service.py,sha256=yo3hhz4UlKtYBY3DoyJjqXfDJPNfhNdGivvzPkW2S_I,4469
-sycommon/database/async_database_service.py,sha256=Cf3RaO3skP6IAJrkta-CRE-Q1NtjWLPLUe9hazB8LRM,4873
+sycommon/database/async_database_service.py,sha256=UPQ4Y0Cpioyav5tdFHr40lvkV5uTH2UZRS853663fy4,5380
 sycommon/database/base_db_service.py,sha256=urdAibaCUt3hxwwKzEMBceWkIwsw3ja_WDJ1QKc8nLU,4116
-sycommon/database/database_service.py,sha256=IMoJ9554dYkr6QfRofvNa0VR24U1WQDz_ATrg0-6EQ0,3857
+sycommon/database/database_service.py,sha256=rbbII50EI4VTTkwrFiw9PnvW6LgR5yQvN8aJblUu1Oc,4352
 sycommon/database/elasticsearch_service.py,sha256=qm490GRlxZlYsQgyfyclSbARRP1-Tc4Lwav3lbPINvQ,3092
 sycommon/database/pg_checkpoint_service.py,sha256=wYVVgIPCsXD0fdwADTJpaRfjqVN0twptJva_ROWZEDQ,5203
 sycommon/database/redis_service.py,sha256=tPw8UgeuyYQBxWfPRjx7VqlSRFNxIsnR0WSGd36GaA8,20509
@@ -195,7 +195,7 @@ sycommon/llm/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkh
 sycommon/llm/tiktoken_cache/fb374d419588a4632f3f557e76b4b70aebbca790,sha256=RGqVOMtsNI41FhINfAiwn1fDZJXirP_-WaW_iwz7Gi0,3613922
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/logging/async_sql_logger.py,sha256=_OY36XkUm__U3NhMgiecy-qd-nptZ_0gpE3J8lGAr58,2619
-sycommon/logging/kafka_log.py,sha256=nhM73AbwdAFVpP-_8mCG74ZXCOzgSfPEAfIK2y0wRpw,13191
+sycommon/logging/kafka_log.py,sha256=5tbCYMLEm7RwfWoYQMZU96xjaEGG6T0QfBhglxT5Q8E,13310
 sycommon/logging/logger_levels.py,sha256=_-uQ_T1N8NkNgcAmLrMmJ83nHTDw5ZNvXFPvdk89XGY,1144
 sycommon/logging/logger_wrapper.py,sha256=TtzmGw_K5NjBGBq9Gjqtnh834izAv8TQwsOeL2fIbAI,481
 sycommon/logging/process_logger.py,sha256=rjunPTaDejtusvobSrc3G44DEqnt_bbNSY3r8cWqBsY,5895
@@ -213,8 +213,8 @@ sycommon/middleware/mq.py,sha256=9X6KKtadFjBXKS5L3kEKujYio9wwGfWgXwWOAHO-HDg,254
 sycommon/middleware/sandbox.py,sha256=er0zeHLQtHJqSr27fGcKbAtRo1ZOQ-Lqif8ALWNFSak,47858
 sycommon/middleware/timeout.py,sha256=KlxOPa8xl2dg6yuRi_EzkVJG8bX4stb5ueYxctzzGM8,1433
 sycommon/middleware/token_tracking.py,sha256=rEbgV1bgWMdzAERx4aq5XAvOIT6jTY_tK1P0xHJnL3o,6609
-sycommon/middleware/tool_result_truncation.py,sha256=C5739a3HkpiEPLplTnBTGcVOUvkd-lQBl3oYsM0_7rI,10129
-sycommon/middleware/traceid.py,sha256=HX4zg7Tp_mPNr2eWDDvK3f7GFJ6eOSeW062Xcc-xshc,14340
+sycommon/middleware/tool_result_truncation.py,sha256=307qUekFbhrh5x8rLYgoOOSH1Ph7doTicrpTiyiZo_A,10715
+sycommon/middleware/traceid.py,sha256=MrcHj-2hzwl5sOMbf6-34tezYv4COnh3R8vaCN9zRuA,14025
 sycommon/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/models/base_http.py,sha256=EICAAibx3xhjBsLqm35Mi3DCqxp0FME4rD_3iQVjT_E,3051
 sycommon/models/log.py,sha256=rZpj6VkDRxK3B6H7XSeWdYZshU8F0Sks8bq1p6pPlDw,500
@@ -279,8 +279,8 @@ sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,561
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
 sycommon/xxljob/__init__.py,sha256=7eoBlQxv-B39IfRSCY2bkqdGYs1QRe1umAWd88VMEEM,86
 sycommon/xxljob/xxljob_service.py,sha256=JIEJaGXhqrTLcyxlyynSrsHg9bBnDNzX-D4qIWLRPUE,6815
-sycommon_python_lib-0.2.5a29.dist-info/METADATA,sha256=Fm8XMMlZubGy8kCj8-tsd-eTL0DE6XxA-y7TFS1gpM0,7914
-sycommon_python_lib-0.2.5a29.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.5a29.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.5a29.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.5a29.dist-info/RECORD,,
+sycommon_python_lib-0.2.5a31.dist-info/METADATA,sha256=QP-iiLOW9iiICa42zGhSK_x_iWW2TTmRNp-9IMhee6c,7914
+sycommon_python_lib-0.2.5a31.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.5a31.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.5a31.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.5a31.dist-info/RECORD,,