sycommon-python-lib 0.2.1a19__tar.gz → 0.2.1a21__tar.gz

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/PKG-INFO

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

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.1a19"
+version = "0.2.1a21"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/src/sycommon/agent/sandbox/__init__.py

@@ -76,6 +76,7 @@ from sycommon.agent.sandbox.sandbox_pool import (
     areset_all_sandboxes,
     aget_sandbox_status,
 )
+from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 
 __all__ = [
     # 后端
@@ -85,6 +86,9 @@ __all__ = [
     "SandboxPool",
     "SandboxInstance",
 
+    # 恢复管理
+    "SandboxRecoveryManager",
+
     # 便捷函数
     "areset_all_sandboxes",
     "aget_sandbox_status",

sycommon_python_lib-0.2.1a21/src/sycommon/agent/sandbox/sandbox_recovery.py

@@ -0,0 +1,197 @@
+"""
+沙箱恢复管理器
+
+处理沙箱不可用时的自动切换和恢复逻辑
+"""
+
+import asyncio
+from typing import Optional
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_service import NacosService
+
+
+class SandboxRecoveryManager:
+    """沙箱恢复管理器 - 处理沙箱不可用时的自动切换
+
+    使用示例:
+        from sycommon.agent.sandbox import HTTPSandboxBackend, SandboxRecoveryManager
+
+        sandbox = HTTPSandboxBackend.from_nacos("sandbox-service", user_id="user123")
+        recovery = SandboxRecoveryManager(sandbox)
+
+        # 尝试恢复
+        if await recovery.recover():
+            print("沙箱已恢复")
+    """
+
+    def __init__(
+        self,
+        sandbox_backend: "HTTPSandboxBackend",
+        check_interval: int = 15,
+        max_failures: int = 3,
+        health_check_timeout: int = 15,
+        sync_timeout: int = 300,
+    ):
+        """
+        初始化恢复管理器
+
+        Args:
+            sandbox_backend: 沙箱后端实例
+            check_interval: 健康检查间隔（秒），默认15秒
+            max_failures: 触发切换的连续失败次数，默认3次（连续3次失败才触发切换）
+            health_check_timeout: 单次健康检查超时（秒），默认15秒
+            sync_timeout: 目录同步超时（秒），默认300秒（5分钟）
+        """
+        self.backend = sandbox_backend
+        self._check_interval = check_interval
+        self._max_failures = max_failures
+        self._health_check_timeout = health_check_timeout
+        self._sync_timeout = sync_timeout
+        self._consecutive_failures = 0
+
+    async def check_health(self) -> bool:
+        """检查沙箱是否健康（单次检查）
+
+        Returns:
+            bool: 健康返回 True，否则返回 False
+        """
+        try:
+            result = await asyncio.wait_for(
+                self.backend.aexecute("echo 'health_check'", timeout=10),
+                timeout=self._health_check_timeout
+            )
+            is_healthy = result.exit_code == 0
+            if is_healthy:
+                # 一次成功，立马重置失败计数，沙箱健康
+                self._consecutive_failures = 0
+            return is_healthy
+        except Exception as e:
+            SYLogger.debug(f"[Sandbox] 健康检查异常: {e}")
+            return False
+
+    async def recover(self) -> bool:
+        """尝试恢复：执行健康检查，连续失败达阈值时切换沙箱
+
+        逻辑：
+        - 一次健康检查成功 → 立马返回 True（沙箱健康）
+        - 连续失败 < max_failures → 返回 False（继续等待检查）
+        - 连续失败 >= max_failures → 触发切换
+
+        Returns:
+            bool: 恢复成功/沙箱健康返回 True，否则返回 False
+        """
+        # 健康检查（成功会自动重置失败计数）
+        if await self.check_health():
+            return True
+
+        # 检查失败，累计失败次数
+        self._consecutive_failures += 1
+        SYLogger.warning(
+            f"[Sandbox] 健康检查失败 "
+            f"({self._consecutive_failures}/{self._max_failures})"
+        )
+
+        if self._consecutive_failures < self._max_failures:
+            return False
+
+        # 连续失败达到阈值，切换沙箱
+        SYLogger.info("[Sandbox] 连续失败达到阈值，尝试切换沙箱...")
+        return await self._switch_to_healthy_sandbox()
+
+    async def wait_and_recover(self) -> bool:
+        """等待检查间隔后尝试恢复
+
+        每等待 check_interval 秒后执行一次 recover()
+
+        Returns:
+            bool: 恢复成功返回 True，否则返回 False
+        """
+        await asyncio.sleep(self._check_interval)
+        return await self.recover()
+
+    async def _switch_to_healthy_sandbox(self) -> bool:
+        """切换到健康的沙箱实例
+
+        优先使用底层已有的切换逻辑（会尝试迁移工作空间文件），
+        如果失败则手动从 Nacos 获取新实例并同步。
+
+        Returns:
+            bool: 切换成功返回 True，否则返回 False
+        """
+        # 优先使用底层已有的切换逻辑（会尝试迁移工作空间文件）
+        switched = await self.backend._refresh_from_nacos_and_switch()
+
+        if switched:
+            self._consecutive_failures = 0
+            SYLogger.info(f"[Sandbox] 已切换到新沙箱: {self.backend.base_url}")
+            return True
+
+        # 底层切换失败，手动切换并同步原始目录
+        return await self._manual_switch()
+
+    async def _manual_switch(self) -> bool:
+        """手动切换：重新从 Nacos 获取并同步原始目录
+
+        当底层 _refresh_from_nacos_and_switch 失败时（如旧沙箱已完全不可用），
+        手动从 Nacos 获取新实例，并同步用户原始的 sync_dirs 目录。
+
+        Returns:
+            bool: 切换成功返回 True，否则返回 False
+        """
+        try:
+            nacos_manager = NacosService(None)
+
+            if not hasattr(nacos_manager, 'discovery'):
+                SYLogger.error("[Sandbox] NacosService 未初始化")
+                return False
+
+            instances = nacos_manager.get_service_instances(
+                self.backend._nacos_service_name,
+                group=self.backend._nacos_group
+            )
+
+            if not instances:
+                SYLogger.error(f"[Sandbox] Nacos 无可用实例: {self.backend._nacos_service_name}")
+                return False
+
+            # 找一个不同的实例
+            for instance in instances:
+                new_url = f"http://{instance['ip']}:{instance['port']}"
+                if new_url != self.backend.base_url:
+                    old_url = self.backend.base_url
+                    SYLogger.info(f"[Sandbox] 手动切换: {old_url} -> {new_url}")
+
+                    # 切换 URL
+                    self.backend._base_url = new_url
+                    self.backend._synced = False
+
+                    # 同步用户原始目录
+                    if self.backend._sync_dirs:
+                        SYLogger.info("[Sandbox] 同步原始目录到新沙箱...")
+                        try:
+                            await asyncio.wait_for(
+                                self.backend.async_sync(),
+                                timeout=self._sync_timeout
+                            )
+                        except asyncio.TimeoutError:
+                            SYLogger.warning(f"[Sandbox] 同步超时 ({self._sync_timeout}s)，继续执行")
+
+                    self._consecutive_failures = 0
+                    SYLogger.info("[Sandbox] 手动切换完成")
+                    return True
+
+            SYLogger.warning("[Sandbox] 无其他可用实例")
+            return False
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 手动切换失败: {e}")
+            return False
+
+    @property
+    def consecutive_failures(self) -> int:
+        """连续失败次数"""
+        return self._consecutive_failures
+
+    def reset_failures(self):
+        """重置失败计数"""
+        self._consecutive_failures = 0

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/src/sycommon/llm/token_usage_mysql_service.py

@@ -3,34 +3,22 @@ Token 使用量记录服务（MySQL版本）
 按用户+系统+日期维度聚合存储，每个人每天每个系统只保留一条记录
 
 使用独立的数据库连接（llm 配置中的数据库），与业务系统数据库隔离
-
-高并发优化：
-1. 本地内存缓冲：减少数据库写入频率
-2. 智能聚合：相同 key 的请求在内存中累加
-3. 批量写入：合并多次写入为单次批量操作
-4. 异步刷新：定时将缓冲区数据写入数据库
 """
 import asyncio
 import logging
-import random
 from datetime import datetime, date
 from typing import Optional, Dict, Any, List
 
 from sqlalchemy import select, text
 from sqlalchemy.dialects.mysql import insert
-from sqlalchemy.exc import OperationalError
 
 from sycommon.config.Config import SingletonMeta, Config
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.database.token_usage_db_service import TokenUsageDBService
 from sycommon.models.token_usage_mysql import TokenUsageMySQL
-from sycommon.llm.token_usage_buffer import TokenUsageBuffer, TokenUsageBufferItem
 
 logger = SYLogger
 
-# MySQL lock wait timeout error code
-MYSQL_LOCK_WAIT_TIMEOUT = 1205
-
 
 class TokenUsageMySQLService(metaclass=SingletonMeta):
     """Token 使用量记录服务（MySQL异步版本）
@@ -45,16 +33,6 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
     _service_name: Optional[str] = None
     _system_env: Optional[str] = None
 
-    # Retry configuration for lock wait timeout
-    _max_retries: int = 3
-    _base_delay: float = 0.5  # Base delay in seconds
-    _max_delay: float = 5.0  # Maximum delay in seconds
-
-    # Buffer configuration (for high concurrency optimization)
-    _use_buffer: bool = True  # 是否启用缓冲（默认启用）
-    _buffer_flush_interval: float = 15.0  # 缓冲刷新间隔（秒）
-    _buffer_max_size: int = 500  # 缓冲区最大条目数
-
     def __init__(self):
         pass
 
@@ -104,81 +82,11 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                 asyncio.create_task(cls._ensure_table())
                 cls._initialized = True
                 logging.info("TokenUsageMySQLService 初始化成功")
-
-                # 初始化缓冲区（高并发优化）
-                if cls._use_buffer:
-                    cls._init_buffer()
             else:
                 logging.warning("TokenUsageMySQLService 初始化失败: 数据库服务未就绪")
         except Exception as e:
             logging.warning(f"TokenUsageMySQLService 初始化失败: {e}")
 
-    @classmethod
-    def _init_buffer(cls):
-        """初始化缓冲区"""
-        TokenUsageBuffer.configure(
-            flush_interval=cls._buffer_flush_interval,
-            max_buffer_size=cls._buffer_max_size,
-            max_batch_size=100
-        )
-        TokenUsageBuffer.set_flush_callback(cls._flush_buffer_to_db)
-
-        # 启动缓冲区（异步）
-        try:
-            loop = asyncio.get_running_loop()
-            loop.create_task(TokenUsageBuffer.start())
-            logging.info("TokenUsageMySQLService 缓冲区已启动")
-        except RuntimeError:
-            # 没有运行中的事件循环，延迟启动
-            logging.info("TokenUsageMySQLService 缓冲区将在首次使用时启动")
-
-    @classmethod
-    async def _flush_buffer_to_db(cls, items: List[TokenUsageBufferItem]):
-        """
-        将缓冲区数据批量写入数据库
-
-        Args:
-            items: 缓冲区中的记录列表
-        """
-        if not items or not cls._db_service:
-            return
-
-        try:
-            # 确保表存在
-            await cls._ensure_table()
-
-            async with cls._db_service.session() as session:
-                # 构建批量 upsert 语句
-                values = []
-                for item in items:
-                    values.append({
-                        'user_id': item.user_id,
-                        'tenant_id': item.tenant_id,
-                        'service_name': item.service_name,
-                        'system_env': item.system_env,
-                        'input_tokens': item.input_tokens,
-                        'output_tokens': item.output_tokens,
-                        'total_tokens': item.input_tokens + item.output_tokens,
-                        'model': item.model,
-                        'usage_date': item.usage_date
-                    })
-
-                if values:
-                    stmt = insert(TokenUsageMySQL).values(values)
-                    stmt = stmt.on_duplicate_key_update(
-                        input_tokens=TokenUsageMySQL.input_tokens + insert(TokenUsageMySQL).input_tokens,
-                        output_tokens=TokenUsageMySQL.output_tokens + insert(TokenUsageMySQL).output_tokens,
-                        total_tokens=TokenUsageMySQL.total_tokens + insert(TokenUsageMySQL).total_tokens,
-                        model=insert(TokenUsageMySQL).model,
-                        updated_at=datetime.now()
-                    )
-                    await session.execute(stmt)
-                    logging.info(f"TokenUsageMySQLService 批量写入 {len(items)} 条记录成功")
-
-        except Exception as e:
-            logging.error(f"TokenUsageMySQLService 批量写入失败: {e}", exc_info=True)
-            raise
-
     @classmethod
     async def _ensure_table(cls):
         """确保表存在"""
@@ -231,10 +139,7 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
         system_env: Optional[str] = None
     ) -> bool:
         """
-        同步记录 Token 使用量（Fire-and-forget 模式，非阻塞）
-
-        高并发优化：使用本地缓冲区，定时批量写入数据库
-        完全不阻塞主服务，使用内存缓冲 + 后台异步刷新
+        同步记录 Token 使用量（Fire-and-forget 模式）
 
         Args:
             user_id: 用户ID（从请求头获取，没有则为空）
@@ -265,38 +170,32 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
         if system_env is None:
             system_env = cls._system_env
 
-        # 优先使用缓冲区（高并发优化，非阻塞）
-        if cls._use_buffer:
-            # 确保缓冲区已启动（异步启动，不阻塞）
-            cls._ensure_buffer_started()
-            # 使用同步添加方法，完全非阻塞
-            return TokenUsageBuffer.add_sync(
-                user_id=user_id,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                model=model,
-                tenant_id=tenant_id,
-                service_name=service_name,
-                system_env=system_env
-            )
+        logging.info(
+            f"TokenUsageMySQLService record_sync: service_name={service_name}, system_env={system_env}, cls._service_name={cls._service_name}, cls._system_env={cls._system_env}")
 
-        # 缓冲区未启用，异步写入数据库（非阻塞）
         try:
-            loop = asyncio.get_running_loop()
-            task = loop.create_task(cls._do_record(
-                user_id=user_id,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                model=model,
-                tenant_id=tenant_id,
-                service_name=service_name,
-                system_env=system_env
-            ))
-            task.add_done_callback(cls._handle_task_exception)
-            return True
-        except RuntimeError:
-            # 没有运行中的事件循环，使用 asyncio.run（会阻塞，但这是边缘情况）
             try:
+                loop = asyncio.get_running_loop()
+                # 创建任务并添加回调处理异常，避免静默失败
+                task = loop.create_task(cls._do_record(
+                    user_id=user_id,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    model=model,
+                    tenant_id=tenant_id,
+                    service_name=service_name,
+                    system_env=system_env
+                ))
+                # 添加回调处理异常
+
+                def _handle_task_exception(t):
+                    try:
+                        t.result()
+                    except Exception as e:
+                        logging.error(f"Token 记录任务失败: {e}", exc_info=True)
+                task.add_done_callback(_handle_task_exception)
+            except RuntimeError:
+                # 没有运行中的事件循环，使用 asyncio.run
                 asyncio.run(cls._do_record(
                     user_id=user_id,
                     input_tokens=input_tokens,
@@ -306,30 +205,10 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                     service_name=service_name,
                     system_env=system_env
                 ))
-                return True
-            except Exception as e:
-                logging.error(f"记录 Token 使用量失败: {e}", exc_info=True)
-                return False
-
-    @classmethod
-    def _ensure_buffer_started(cls):
-        """确保缓冲区已启动（非阻塞）"""
-        if TokenUsageBuffer.is_running():
-            return
-
-        try:
-            loop = asyncio.get_running_loop()
-            loop.create_task(TokenUsageBuffer.start())
-        except RuntimeError:
-            pass
-
-    @classmethod
-    def _handle_task_exception(cls, task):
-        """处理异步任务异常"""
-        try:
-            task.result()
+            return True
         except Exception as e:
-            logging.error(f"Token 记录任务失败: {e}", exc_info=True)
+            logging.error(f"记录 Token 使用量失败: {e}", exc_info=True)
+            return False
 
     @classmethod
     async def record(
@@ -346,8 +225,6 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
         """
         异步记录 Token 使用量
 
-        高并发优化：优先使用本地缓冲区，定时批量写入数据库
-
         每个用户每个服务每天只保留一条记录，如果存在则累加更新
 
         Args:
@@ -378,23 +255,6 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
         if system_env is None:
             system_env = cls._system_env
 
-        # 优先使用缓冲区（高并发优化，非阻塞）
-        if cls._use_buffer:
-            # 确保缓冲区已启动
-            if not TokenUsageBuffer.is_running():
-                await TokenUsageBuffer.start()
-            # 使用同步添加方法（非阻塞）
-            return TokenUsageBuffer.add_sync(
-                user_id=user_id,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                model=model,
-                tenant_id=tenant_id,
-                service_name=service_name,
-                system_env=system_env
-            )
-
-        # 缓冲区未启用，直接写入数据库
         return await cls._do_record(
             user_id=user_id,
             input_tokens=input_tokens,
@@ -418,7 +278,6 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
     ) -> bool:
         """
         执行记录操作（使用 MySQL INSERT ON DUPLICATE KEY UPDATE 实现 upsert）
-        包含重试机制处理锁等待超时
         """
         if not cls._db_service:
             return False
@@ -447,69 +306,31 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
             service_name = service_name or ''
             system_env = system_env or ''
 
-            # Retry loop with exponential backoff
-            last_exception = None
-            for attempt in range(cls._max_retries):
-                try:
-                    async with cls._db_service.session() as session:
-                        # 使用 MySQL 的 INSERT ... ON DUPLICATE KEY UPDATE
-                        stmt = insert(TokenUsageMySQL).values(
-                            user_id=user_id,
-                            tenant_id=tenant_id,
-                            service_name=service_name,
-                            system_env=system_env,
-                            input_tokens=input_tokens,
-                            output_tokens=output_tokens,
-                            total_tokens=total,
-                            model=model,
-                            usage_date=today
-                        )
-
-                        # 冲突时累加更新
-                        stmt = stmt.on_duplicate_key_update(
-                            input_tokens=TokenUsageMySQL.input_tokens + input_tokens,
-                            output_tokens=TokenUsageMySQL.output_tokens + output_tokens,
-                            total_tokens=TokenUsageMySQL.total_tokens + total,
-                            model=model,  # 更新为最新使用的模型
-                            updated_at=datetime.now()
-                        )
-
-                        await session.execute(stmt)
-                        return True
-
-                except OperationalError as e:
-                    last_exception = e
-                    # Check if it's a lock wait timeout error
-                    if hasattr(e, 'orig') and hasattr(e.orig, 'args'):
-                        error_code = e.orig.args[0] if e.orig.args else None
-                    elif hasattr(e, 'args') and e.args:
-                        error_code = e.args[0]
-                    else:
-                        error_code = None
-
-                    if error_code == MYSQL_LOCK_WAIT_TIMEOUT:
-                        if attempt < cls._max_retries - 1:
-                            # Calculate delay with exponential backoff and jitter
-                            delay = min(
-                                cls._base_delay * (2 ** attempt) + random.uniform(0, 0.5),
-                                cls._max_delay
-                            )
-                            logging.warning(
-                                f"Token 记录遇到锁等待超时，第 {attempt + 1} 次重试，"
-                                f"等待 {delay:.2f} 秒后重试..."
-                            )
-                            await asyncio.sleep(delay)
-                            continue
-                        else:
-                            logging.error(
-                                f"Token 记录在 {cls._max_retries} 次重试后仍然失败（锁等待超时）"
-                            )
-                    else:
-                        # Re-raise non-lock-timeout operational errors
-                        raise
-
-            logging.error(f"记录 Token 使用量到 MySQL 失败: {last_exception}", exc_info=True)
-            return False
+            async with cls._db_service.session() as session:
+                # 使用 MySQL 的 INSERT ... ON DUPLICATE KEY UPDATE
+                stmt = insert(TokenUsageMySQL).values(
+                    user_id=user_id,
+                    tenant_id=tenant_id,
+                    service_name=service_name,
+                    system_env=system_env,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total,
+                    model=model,
+                    usage_date=today
+                )
+
+                # 冲突时累加更新
+                stmt = stmt.on_duplicate_key_update(
+                    input_tokens=TokenUsageMySQL.input_tokens + input_tokens,
+                    output_tokens=TokenUsageMySQL.output_tokens + output_tokens,
+                    total_tokens=TokenUsageMySQL.total_tokens + total,
+                    model=model,  # 更新为最新使用的模型
+                    updated_at=datetime.now()
+                )
+
+                await session.execute(stmt)
+                return True
 
         except Exception as e:
             logging.error(f"记录 Token 使用量到 MySQL 失败: {e}", exc_info=True)
@@ -1059,50 +880,3 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
             order_by="total_tokens",
             order_desc=True
         )
-
-    @classmethod
-    def configure_buffer(
-        cls,
-        use_buffer: bool = True,
-        flush_interval: float = 5.0,
-        max_buffer_size: int = 500
-    ):
-        """
-        配置缓冲区参数
-
-        Args:
-            use_buffer: 是否启用缓冲区（默认 True）
-            flush_interval: 刷新间隔（秒），默认 5 秒
-            max_buffer_size: 缓冲区最大条目数，默认 500
-        """
-        cls._use_buffer = use_buffer
-        cls._buffer_flush_interval = flush_interval
-        cls._buffer_max_size = max_buffer_size
-
-        if cls._use_buffer:
-            TokenUsageBuffer.configure(
-                flush_interval=flush_interval,
-                max_buffer_size=max_buffer_size
-            )
-            logging.info(
-                f"TokenUsageMySQLService 缓冲区配置: enabled={use_buffer}, "
-                f"flush_interval={flush_interval}s, max_buffer_size={max_buffer_size}"
-            )
-        else:
-            logging.info("TokenUsageMySQLService 缓冲区已禁用")
-
-    @classmethod
-    async def flush_buffer(cls):
-        """手动刷新缓冲区到数据库"""
-        await TokenUsageBuffer.flush_now()
-
-    @classmethod
-    def get_buffer_stats(cls) -> Dict[str, Any]:
-        """获取缓冲区统计信息"""
-        return TokenUsageBuffer.get_stats()
-
-    @classmethod
-    async def stop_buffer(cls):
-        """停止缓冲区并刷新剩余数据（服务关闭时调用）"""
-        await TokenUsageBuffer.stop()
-

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/src/sycommon_python_lib.egg-info/PKG-INFO

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

{sycommon_python_lib-0.2.1a19 → sycommon_python_lib-0.2.1a21}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ src/sycommon/agent/sandbox/__init__.py
 src/sycommon/agent/sandbox/file_ops.py
 src/sycommon/agent/sandbox/http_sandbox_backend.py
 src/sycommon/agent/sandbox/sandbox_pool.py
+src/sycommon/agent/sandbox/sandbox_recovery.py
 src/sycommon/agent/sandbox/session.py
 src/sycommon/agent/skills/__init__.py
 src/sycommon/agent/skills/exports.py
@@ -85,7 +86,6 @@ src/sycommon/llm/native_with_fallback_runnable.py
 src/sycommon/llm/output_fixing_runnable.py
 src/sycommon/llm/struct_token.py
 src/sycommon/llm/sy_langfuse.py
-src/sycommon/llm/token_usage_buffer.py
 src/sycommon/llm/token_usage_es_service.py
 src/sycommon/llm/token_usage_mysql_service.py
 src/sycommon/llm/usage_token.py