sycommon-python-lib 0.2.5a25__tar.gz → 0.2.5a27__tar.gz

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a25
+Version: 0.2.5a27
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.6.4
+Requires-Dist: deepagents==0.6.6
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.5a25"
+version = "0.2.5a27"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -10,7 +10,7 @@ dependencies = [
     "aiomysql==0.3.2",
     "anyio==4.13.0",
     "decorator==5.3.1",
-    "deepagents==0.6.4",
+    "deepagents==0.6.6",
     "elasticsearch==9.4.1",
     "fastapi==0.136.3",
     "jinja2==3.1.6",
@@ -54,6 +54,11 @@ package-data = {command = ["templates/**/*", "templates/**/.*"], sycommon = ["ll
 requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]
+
 [project.scripts]
 sycommon = "command.cli:main"
 sycli = "sycli.cli:main"

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/agent/chat_events.py

@@ -62,6 +62,9 @@ class EventType(str, Enum):
     PARALLEL_AGENTS = "parallel_agents"  # 并行 Agent
     AGENT_COMPLETE = "agent_complete"  # Agent 任务完成
 
+    # 评分相关
+    RUBRIC_EVALUATION = "rubric_evaluation"  # Rubric 评估结果
+
     # 生命周期
     DONE = "done"  # 完成
     ERROR = "error"  # 错误
@@ -368,6 +371,39 @@ class ChatEventBuilder:
         """
         return ChatEvent(EventType.CANCELLED, {"message": message})
 
+    # ============== 评分相关 ==============
+
+    @staticmethod
+    def rubric_evaluation(
+        iteration: int,
+        result: str,
+        criteria: list,
+        explanation: str = "",
+        agent: str = DEFAULT_AGENT_NAME,
+    ) -> ChatEvent:
+        """
+        构建 Rubric 评估事件
+
+        Args:
+            iteration: 评估迭代次数
+            result: 评估结果（satisfied / needs_revision / failed / max_iterations_reached / grader_error）
+            criteria: 各评分标准的判定列表
+            explanation: 评估说明
+            agent: Agent 名称
+
+        Returns:
+            ChatEvent: 评估事件
+        """
+        data = {
+            "iteration": iteration,
+            "result": result,
+            "criteria": criteria,
+            "agent": agent,
+        }
+        if explanation:
+            data["explanation"] = explanation
+        return ChatEvent(EventType.RUBRIC_EVALUATION, data)
+
 
 # ============== 便捷函数（直接返回字典，兼容旧代码） ==============
 

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/agent/deep_agent.py

@@ -117,10 +117,28 @@ class AgentConfig(BaseModel):
     # 调试模式
     debug: bool = False
 
+    # Rubric 评分配置
+    rubric_max_iterations: int = 3  # rubric 评估最大迭代次数（0 = 不启用）
+
     class Config:
         arbitrary_types_allowed = True
 
 
+class _RubricEvalCollector:
+    """收集 RubricMiddleware 通过 on_evaluation 回调产生的评估结果"""
+
+    def __init__(self):
+        self.evaluations: list = []
+
+    def on_evaluation(self, evaluation):
+        """RubricMiddleware 每次评估完成后调用"""
+        self.evaluations.append(evaluation)
+
+    @property
+    def latest(self):
+        return self.evaluations[-1] if self.evaluations else None
+
+
 class DeepAgent:
     """数字员工封装类"""
 
@@ -131,12 +149,14 @@ class DeepAgent:
         config: Dict[str, Any],
         sandbox_backend: HTTPSandboxBackend,
         recovery_manager: Optional[SandboxRecoveryManager] = None,
+        rubric_eval_collector: Optional[_RubricEvalCollector] = None,
     ):
         self.user_id = user_id
         self.agent = agent
         self.config = config
         self.sandbox_backend = sandbox_backend
         self.recovery_manager = recovery_manager
+        self.rubric_eval_collector = rubric_eval_collector
 
     async def cleanup(self):
         """清理资源"""
@@ -149,6 +169,7 @@ class DeepAgent:
     async def chat(
         self,
         message: str,
+        rubric: Optional[str] = None,
         cancel_event: Optional[asyncio.Event] = None,
         on_event: Optional[Callable[[ChatEvent], Awaitable[None]]] = None,
     ) -> AsyncGenerator[ChatEvent, None]:
@@ -156,6 +177,7 @@ class DeepAgent:
 
         Args:
             message: 用户消息
+            rubric: 评分标准（可选），传入后 agent 完成时会自动评估是否满足标准
             cancel_event: 取消事件（用于取消当前任务）
             on_event: 事件回调，每个事件触发后调用（可用于 DB 持久化等）
 
@@ -172,8 +194,11 @@ class DeepAgent:
         total_output_tokens = 0
 
         try:
+            input_state = {"messages": [HumanMessage(content=message)]}
+            if rubric:
+                input_state["rubric"] = rubric
             async for chunk in self._astream_with_retry(
-                {"messages": [HumanMessage(content=message)]},
+                input_state,
                 max_retries=3,
                 base_delay=1.0,
             ):
@@ -650,6 +675,8 @@ async def create_deep_agent(
 
     # 创建 agent
     from deepagents import create_deep_agent as _create_deep_agent
+    from deepagents import RubricMiddleware
+    from deepagents.middleware.filesystem import FilesystemMiddleware
 
     # 创建 compact_conversation 工具 middleware
     # 自动压缩由 deepagents 内置的 SummarizationMiddleware 处理（通过 model.profile 获取阈值）
@@ -657,6 +684,27 @@ async def create_deep_agent(
         model, config.model_name, sandbox_backend,
     )
 
+    # 🔑 Rubric 评估收集器：通过 on_evaluation 回调收集评估结果
+    rubric_eval_collector = None
+
+    # 构建 middleware 列表
+    middleware_list = [
+        ToolResultTruncationMiddleware(),
+        TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
+        summarization_mw,
+    ]
+
+    # RubricMiddleware：复用 FilesystemMiddleware 的工具（底层走 HTTPSandboxBackend HTTP 远程调用）
+    if config.rubric_max_iterations > 0 and sandbox_backend:
+        rubric_eval_collector = _RubricEvalCollector()
+        _rubric_fs_middleware = FilesystemMiddleware(backend=sandbox_backend)
+        middleware_list.append(RubricMiddleware(
+            model=model,
+            tools=_rubric_fs_middleware.tools,
+            max_iterations=config.rubric_max_iterations,
+            on_evaluation=rubric_eval_collector.on_evaluation,
+        ))
+
     agent_kwargs = {
         "model": model,
         "tools": config.tools or [get_current_date],
@@ -664,11 +712,7 @@ async def create_deep_agent(
         "checkpointer": checkpointer,
         "system_prompt": config.system_prompt,
         "debug": config.debug,
-        "middleware": [
-            ToolResultTruncationMiddleware(),
-            TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
-            summarization_mw,
-        ],
+        "middleware": middleware_list,
     }
     if skills_path:
         agent_kwargs["skills"] = [skills_path]
@@ -685,6 +729,7 @@ async def create_deep_agent(
         config=agent_config,
         sandbox_backend=sandbox_backend,
         recovery_manager=recovery_manager,
+        rubric_eval_collector=rubric_eval_collector,
     )
 
 

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/agent/sandbox/file_ops.py

@@ -510,9 +510,15 @@ class FileOperationsMixin:
             })
             # GrepResponse: {"matches": [...], "partial_error": "...", "error": "..."}
             matches = [GrepMatch(**item) for item in result.get("matches", [])]
+            # deepagents GrepResult 只有 error 和 matches 字段，
+            # 将 partial_error 合并到 error 中（部分失败但有结果时不设 error）
+            partial_error = result.get("partial_error")
+            error = result.get("error")
+            if not error and partial_error and not matches:
+                error = partial_error
             return GrepResult(
                 matches=matches,
-                error=result.get("error"),
+                error=error,
             )
         except Exception as e:
             SYLogger.error(f"[Sandbox] grep 搜索失败: {e}")
@@ -537,9 +543,13 @@ class FileOperationsMixin:
             }, timeout=timeout)
             # GrepResponse: {"matches": [...], "partial_error": "...", "error": "..."}
             matches = [GrepMatch(**item) for item in result.get("matches", [])]
+            partial_error = result.get("partial_error")
+            error = result.get("error")
+            if not error and partial_error and not matches:
+                error = partial_error
             return GrepResult(
                 matches=matches,
-                error=result.get("error"),
+                error=error,
             )
         except Exception as e:
             SYLogger.error(f"[Sandbox] 异步 grep 搜索失败: {e}")

sycommon_python_lib-0.2.5a27/src/sycommon/database/async_base_db_service.py

@@ -0,0 +1,114 @@
+import asyncio
+from contextlib import asynccontextmanager
+from sqlalchemy.exc import OperationalError, InterfaceError, InternalError
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sycommon.config.Config import SingletonMeta
+from sycommon.database.async_database_service import AsyncDatabaseService
+from sycommon.logging.kafka_log import SYLogger
+
+# 连接级错误：连接已断，事务必定已丢失，重试安全
+_CONNECTION_ERROR_CODES = {2006, 2013}
+# 事务级错误：死锁、锁等待超时，由调用方决定是否重试
+_RETRYABLE_TX_ERROR_CODES = {1205, 1213, 1206}
+
+
+def _is_connection_error(exc: Exception) -> bool:
+    """判断是否为连接级错误（断开、宕机），可安全重试"""
+    if isinstance(exc, (OperationalError, InterfaceError)):
+        if exc.orig and hasattr(exc.orig, 'errno'):
+            return exc.orig.errno in _CONNECTION_ERROR_CODES
+    return False
+
+
+def _is_retryable_tx_error(exc: Exception) -> bool:
+    """判断是否为可重试的事务级错误（死锁、锁超时）"""
+    if isinstance(exc, (OperationalError, InternalError)):
+        if exc.orig and hasattr(exc.orig, 'errno'):
+            return exc.orig.errno in _RETRYABLE_TX_ERROR_CODES
+    return False
+
+
+class AsyncBaseDBService(metaclass=SingletonMeta):
+    """数据库操作基础服务类，封装异步会话管理功能"""
+
+    def __init__(self):
+        self.engine = AsyncDatabaseService.engine()
+        self.Session = async_sessionmaker(
+            bind=self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
+
+    @asynccontextmanager
+    async def session(self):
+        """
+        异步数据库会话上下文管理器
+        自动处理会话的创建、提交、回滚和关闭
+        """
+        async with self.Session() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                SYLogger.error(f"Database operation failed: {str(e)}")
+                raise
+
+    async def execute(self, fn, retry: int = 0):
+        """
+        执行异步数据库操作，支持自动重试
+
+        连接级错误（连接断开 2006/2013）始终自动重试1次。
+        事务级错误（死锁 1213、锁超时 1205）按 retry 参数重试。
+
+        Args:
+            fn: 接收 session 参数的异步可调用对象，例如:
+                async def query(session): return (await session.execute(select(User))).scalars().all()
+            retry: 事务级错误最大重试次数，默认0不重试
+
+        Returns:
+            fn 的返回值
+
+        Usage:
+            result = await self.execute(
+                lambda session: session.execute(select(User)),
+                retry=3
+            )
+        """
+        attempt = 0
+        max_attempts = 1 + max(retry, 0)
+        connection_retried = False
+        last_exc = None
+
+        while True:
+            async with self.Session() as session:
+                try:
+                    result = await fn(session)
+                    await session.commit()
+                    return result
+                except Exception as e:
+                    await session.rollback()
+                    last_exc = e
+
+                    # 连接级错误：始终自动重试1次（不计入 max_attempts）
+                    if _is_connection_error(e) and not connection_retried:
+                        connection_retried = True
+                        SYLogger.warning(
+                            f"DB connection lost (errno={getattr(e.orig, 'errno', None)}), retrying..."
+                        )
+                        attempt += 1
+                        continue
+
+                    # 事务级错误：按 retry 参数重试
+                    if retry > 0 and _is_retryable_tx_error(e) and attempt < max_attempts - 1:
+                        attempt += 1
+                        backoff = min(0.5 * (2 ** (attempt - 1)), 2.0)
+                        SYLogger.warning(
+                            f"DB retryable error (errno={getattr(e.orig, 'errno', None)}), "
+                            f"attempt {attempt}/{max_attempts}, backoff {backoff}s"
+                        )
+                        await asyncio.sleep(backoff)
+                        continue
+
+                    SYLogger.error(f"Database operation failed: {str(e)}")
+                    raise

sycommon_python_lib-0.2.5a27/src/sycommon/database/base_db_service.py

@@ -0,0 +1,114 @@
+import time
+from contextlib import contextmanager
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.exc import OperationalError, InterfaceError, InternalError
+from sycommon.config.Config import SingletonMeta
+from sycommon.database.database_service import DatabaseService
+from sycommon.logging.kafka_log import SYLogger
+
+# 连接级错误：连接已断，事务必定已丢失，重试安全
+_CONNECTION_ERROR_CODES = {2006, 2013}
+# 事务级错误：死锁、锁等待超时，由调用方决定是否重试
+_RETRYABLE_TX_ERROR_CODES = {1205, 1213, 1206}
+
+
+def _is_connection_error(exc: Exception) -> bool:
+    """判断是否为连接级错误（断开、宕机），可安全重试"""
+    if isinstance(exc, (OperationalError, InterfaceError)):
+        if exc.orig and hasattr(exc.orig, 'errno'):
+            return exc.orig.errno in _CONNECTION_ERROR_CODES
+    return False
+
+
+def _is_retryable_tx_error(exc: Exception) -> bool:
+    """判断是否为可重试的事务级错误（死锁、锁超时）"""
+    if isinstance(exc, (OperationalError, InternalError)):
+        if exc.orig and hasattr(exc.orig, 'errno'):
+            return exc.orig.errno in _RETRYABLE_TX_ERROR_CODES
+    return False
+
+
+class BaseDBService(metaclass=SingletonMeta):
+    """数据库操作基础服务类，封装会话管理功能"""
+
+    def __init__(self):
+        self.engine = DatabaseService.engine()
+        self.Session = sessionmaker(bind=self.engine)
+
+    @contextmanager
+    def session(self):
+        """
+        数据库会话上下文管理器
+        自动处理会话的创建、提交、回滚和关闭
+        """
+        session = self.Session()
+        try:
+            yield session
+            session.commit()
+        except Exception as e:
+            session.rollback()
+            SYLogger.error(f"Database operation failed: {str(e)}")
+            raise
+        finally:
+            session.close()
+
+    def execute(self, fn, retry: int = 0):
+        """
+        执行数据库操作，支持自动重试
+
+        连接级错误（连接断开 2006/2013）始终自动重试1次。
+        事务级错误（死锁 1213、锁超时 1205）按 retry 参数重试。
+
+        Args:
+            fn: 接收 session 参数的可调用对象，例如:
+                lambda session: session.query(User).all()
+            retry: 事务级错误最大重试次数，默认0不重试
+
+        Returns:
+            fn 的返回值
+
+        Usage:
+            result = self.execute(
+                lambda session: session.query(User).all(),
+                retry=3
+            )
+        """
+        attempt = 0
+        max_attempts = 1 + max(retry, 0)
+        connection_retried = False
+        last_exc = None
+
+        while True:
+            session = self.Session()
+            try:
+                result = fn(session)
+                session.commit()
+                return result
+            except Exception as e:
+                session.rollback()
+                last_exc = e
+
+                # 连接级错误：始终自动重试1次（不计入 max_attempts）
+                if _is_connection_error(e) and not connection_retried:
+                    connection_retried = True
+                    SYLogger.warning(
+                        f"DB connection lost (errno={getattr(e.orig, 'errno', None)}), retrying..."
+                    )
+                    attempt += 1
+                    continue
+
+                # 事务级错误：按 retry 参数重试
+                if retry > 0 and _is_retryable_tx_error(e) and attempt < max_attempts - 1:
+                    attempt += 1
+                    backoff = min(0.5 * (2 ** (attempt - 1)), 2.0)
+                    SYLogger.warning(
+                        f"DB retryable error (errno={getattr(e.orig, 'errno', None)}), "
+                        f"attempt {attempt}/{max_attempts}, backoff {backoff}s"
+                    )
+                    time.sleep(backoff)
+                    continue
+
+                SYLogger.error(f"Database operation failed: {str(e)}")
+                raise
+            finally:
+                session.close()

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/llm/llm_with_token_tracking.py

@@ -312,15 +312,6 @@ class LLMWithTokenTracking(BaseChatModel):
             return self.llm.profile
         return None
 
-    @property
-    def profile(self):
-        p = self._resolve_model_profile()
-        return p
-
-    @profile.setter
-    def profile(self, value):
-        pass
-
     def bind_tools(self, tools, *, tool_choice=None, **kwargs):
         """绑定工具 - 委托给底层 LLM，返回绑定后的 Runnable"""
         return self.llm.bind_tools(tools, tool_choice=tool_choice, **kwargs)

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/logging/kafka_log.py

@@ -1,6 +1,7 @@
 import os
 import sys
 import json
+import logging
 import socket
 import threading
 import traceback
@@ -176,6 +177,23 @@ class KafkaSink:
                 pass
 
 
+class _InterceptHandler(logging.Handler):
+    """将 stdlib logging 日志桥接到 Loguru，使 asyncio 等第三方库的日志进入 Kafka 管道"""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        frame, depth = logging.currentframe(), 2
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
 class KafkaLogger(metaclass=SingletonMeta):
     _sink_instance = None
 
@@ -206,8 +224,48 @@ class KafkaLogger(metaclass=SingletonMeta):
             diagnose=True
         )
 
+        # 桥接 stdlib logging → Loguru，捕获 asyncio 等第三方库的日志
+        intercept_handler = _InterceptHandler()
+        logging.root.handlers = [intercept_handler]
+        logging.root.setLevel(logging.WARNING)
+
         sys.excepthook = KafkaLogger._handle_exception
 
+        # 注册 asyncio 异常处理器，捕获未处理的 Task 异常
+        KafkaLogger._setup_asyncio_exception_handler()
+
+    @staticmethod
+    def _setup_asyncio_exception_handler():
+        """注册 asyncio 事件循环异常处理器，将未处理的 Task 异常导入 Kafka"""
+        try:
+            loop = asyncio.get_running_loop()
+            loop.set_exception_handler(KafkaLogger._asyncio_exception_handler)
+        except RuntimeError:
+            pass
+
+    @staticmethod
+    def _asyncio_exception_handler(loop, context):
+        """asyncio 未处理异常回调，通过 SYLogger 记录到 Kafka"""
+        message = context.get("exception", context.get("message", "Unknown asyncio error"))
+        exception = context.get("exception")
+
+        if exception:
+            tb_str = "".join(traceback.format_exception(
+                type(exception), exception, exception.__traceback__
+            ))
+        else:
+            tb_str = str(message)
+
+        trace_id = current_trace_id.get() or str(Snowflake.id)
+        error_msg = json.dumps({
+            "trace_id": trace_id,
+            "message": f"asyncio unhandled: {message}",
+            "level": "ERROR",
+            "detail": tb_str,
+        }, ensure_ascii=False)
+
+        logger.opt(exception=True).error(error_msg)
+
     @staticmethod
     def _handle_exception(exc_type, exc_value, exc_traceback):
         if issubclass(exc_type, KeyboardInterrupt):

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/models/mqlistener_config.py

@@ -33,7 +33,7 @@ class RabbitMQListenerConfig(BaseModel):
     auto_parse_json: bool = Field(True, description="是否自动解析JSON消息")
     prefetch_count: int = Field(2, description="同时消费并发数（控制MQ预取与handler并发上限）")
     max_priority: Optional[int] = Field(
-        None, description="队列支持的最大优先级（对应 x-max-priority）")
+        10, description="队列支持的最大优先级（对应 x-max-priority）")
 
     class Config:
         """模型配置"""

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -42,7 +42,7 @@ class RabbitMQClient:
         auto_delete: bool = False,
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
-        max_priority: Optional[int] = None,
+        max_priority: Optional[int] = 10,
         **kwargs,
     ):
         self.connection_pool = connection_pool

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon/services.py

@@ -265,6 +265,14 @@ class Services(metaclass=SingletonMeta):
             sandbox_cleanup_task = None
 
             try:
+                # 注册 asyncio 异常处理器（需在事件循环运行后）
+                try:
+                    from sycommon.logging.kafka_log import KafkaLogger
+                    loop = asyncio.get_running_loop()
+                    loop.set_exception_handler(KafkaLogger._asyncio_exception_handler)
+                except Exception as e:
+                    logging.debug(f"注册 asyncio 异常处理器失败: {e}")
+
                 # 1. 处理数据库服务
                 if database_service:
                     instance._pending_async_db_setup = []

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a25
+Version: 0.2.5a27
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.6.4
+Requires-Dist: deepagents==0.6.6
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -286,4 +286,5 @@ src/sycommon_python_lib.egg-info/dependency_links.txt
 src/sycommon_python_lib.egg-info/entry_points.txt
 src/sycommon_python_lib.egg-info/requires.txt
 src/sycommon_python_lib.egg-info/top_level.txt
+tests/test_asyncio_logging.py
 tests/test_sycli.py

{sycommon_python_lib-0.2.5a25 → sycommon_python_lib-0.2.5a27}/src/sycommon_python_lib.egg-info/requires.txt

@@ -3,7 +3,7 @@ aiohttp==3.13.5
 aiomysql==0.3.2
 anyio==4.13.0
 decorator==5.3.1
-deepagents==0.6.4
+deepagents==0.6.6
 elasticsearch==9.4.1
 fastapi==0.136.3
 jinja2==3.1.6