sycommon-python-lib 0.2.3a3__tar.gz → 0.2.3a5__tar.gz

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/PKG-INFO

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

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/pyproject.toml

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

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/agent/deep_agent.py

@@ -616,7 +616,8 @@ async def create_deep_agent(
     # 创建 agent
     from deepagents import create_deep_agent as _create_deep_agent
 
-    # 根据模型上下文窗口大小配置压缩阈值
+    # 创建 compact_conversation 工具 middleware
+    # 自动压缩由 deepagents 内置的 SummarizationMiddleware 处理（通过 model.profile 获取阈值）
     summarization_mw = build_summarization_middleware(
         model, config.model_name, sandbox_backend,
     )

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/agent/multi_agent_team.py

@@ -584,11 +584,12 @@ async def create_multi_agent_team(
     from deepagents import create_deep_agent
     from deepagents.middleware.subagents import CompiledSubAgent
 
+    summarization_mw = build_summarization_middleware(model, config.model_name, sandbox_backend)
     middleware = [
         BackgroundExecutionMiddleware(backend=sandbox_backend),
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
-        build_summarization_middleware(model, config.model_name, sandbox_backend),
+        summarization_mw,
     ]
     shared = config.shared_tools or [get_current_date]
 
@@ -629,6 +630,7 @@ async def create_multi_agent_team(
 
     # 创建协调者 Agent
     coord_name = config.coordinator_name
+    coord_summarization_mw = build_summarization_middleware(model, config.model_name, sandbox_backend)
     coordinator_agent = create_deep_agent(
         model=model,
         tools=config.shared_tools or [get_current_date],
@@ -644,7 +646,7 @@ async def create_multi_agent_team(
             BackgroundExecutionMiddleware(backend=sandbox_backend),
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
-            build_summarization_middleware(model, config.model_name, sandbox_backend),
+            coord_summarization_mw,
         ],
     )
 

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/agent/summarization_utils.py

@@ -1,7 +1,8 @@
 """上下文压缩 middleware 构建工具。
 
-根据 nacos 中配置的模型 maxTokens，用绝对 token 数设置压缩阈值，
-避免依赖模型 profile 信息（部分模型不提供 profile）。
+根据 nacos 中配置的模型 maxTokens，用绝对 token 数设置压缩阈值。
+仅创建 SummarizationToolMiddleware（compact_conversation 工具），
+自动压缩由 deepagents 内置的 SummarizationMiddleware 处理（通过 model.profile 获取阈值）。
 """
 
 from __future__ import annotations
@@ -27,9 +28,14 @@ def build_summarization_middleware(
     keep_fraction: float = 0.10,
     default_max_tokens: int = 200000,
 ) -> SummarizationToolMiddleware:
-    """根据模型上下文窗口大小构建压缩 middleware。
+    """根据模型上下文窗口大小构建 compact_conversation 工具 middleware。
 
-    使用绝对 token 数而非 fraction 模式，避免要求模型提供 profile 信息。
+    自动压缩由 deepagents 内置的 SummarizationMiddleware 处理，
+    它通过 model.profile.max_input_tokens（由 LLMWithTokenTracking 从 nacos 配置注入）
+    计算压缩阈值。
+
+    此处创建的 SummarizationToolMiddleware 仅提供 compact_conversation 手动压缩工具，
+    使用 nacos 配置的 maxTokens 作为其内部 SummarizationMiddleware 的阈值参数。
 
     Args:
         model: LLM 实例。
@@ -40,7 +46,7 @@ def build_summarization_middleware(
         default_max_tokens: 无法从配置读取时的默认上下文窗口大小。
 
     Returns:
-        SummarizationToolMiddleware 实例（包含自动压缩 + compact_conversation 工具）。
+        SummarizationToolMiddleware 实例（提供 compact_conversation 工具）。
     """
     try:
         from sycommon.config.Config import Config
@@ -65,4 +71,7 @@ def build_summarization_middleware(
             "max_length": 2000,
         },
     )
+    print(f"[Summarization] compact_conversation 工具配置: model={model_name}, max_tokens={max_tokens}, "
+          f"trigger={trigger_tokens} tokens ({trigger_fraction:.0%}), "
+          f"keep={keep_tokens} tokens ({keep_fraction:.0%})")
     return SummarizationToolMiddleware(summ)

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/llm/llm_with_token_tracking.py

@@ -230,6 +230,23 @@ class LLMWithTokenTracking(BaseChatModel):
             "output_tokens": total_output,
         })
 
+    def _resolve_model_profile(self):
+        """从 llmConfig.maxTokens 构建 profile，供 deepagents 计算压缩阈值使用。"""
+        if self.llmConfig and self.llmConfig.maxTokens:
+            return {"max_input_tokens": self.llmConfig.maxTokens}
+        if self.llm and hasattr(self.llm, 'profile') and self.llm.profile:
+            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.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/models/mqlistener_config.py

@@ -32,6 +32,7 @@ class RabbitMQListenerConfig(BaseModel):
     auto_delete: bool = Field(False, description="是否自动删除队列")
     auto_parse_json: bool = Field(True, description="是否自动解析JSON消息")
     prefetch_count: int = Field(2, description="mq同时消费数量")
+    max_concurrent_tasks: int = Field(5, description="handler 最大并发任务数")
 
     class Config:
         """模型配置"""

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -13,6 +13,7 @@ from aio_pika.abc import (
 )
 from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.middleware.context import current_trace_id
 from sycommon.models.mqmsg_model import MQMsgModel
 
 logger = SYLogger
@@ -41,6 +42,7 @@ class RabbitMQClient:
         auto_delete: bool = False,
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
+        max_concurrent_tasks: int = 5,
         **kwargs,
     ):
         self.connection_pool = connection_pool
@@ -73,6 +75,10 @@ class RabbitMQClient:
         self._connect_lock = asyncio.Lock()
         self._reconnect_semaphore = asyncio.Semaphore(1)
 
+        # 异步任务并发控制（方案C：收到即ACK + create_task）
+        self._task_semaphore = asyncio.Semaphore(max_concurrent_tasks)
+        self._running_tasks: set = set()
+
     @property
     async def is_connected(self) -> bool:
         if self._closed:
@@ -231,9 +237,9 @@ class RabbitMQClient:
                         f"后台重连尝试 {attempt + 1}/{max_attempts} 失败: {e}")
             logger.warning(f"后台重连已达最大尝试次数 {max_attempts}，放弃重连")
 
-    async def set_message_handler(self, handler: Callable[..., Coroutine]) -> None:
-        if not inspect.iscoroutinefunction(handler):
-            raise TypeError("消息处理器必须是协程函数")
+    async def set_message_handler(self, handler: Callable) -> None:
+        if not callable(handler):
+            raise TypeError("消息处理器必须是可调用对象")
         self._message_handler = handler
 
     async def _process_message_callback(self, message: AbstractIncomingMessage):
@@ -246,20 +252,50 @@ class RabbitMQClient:
 
             SYLogger.set_trace_id(msg_obj.traceId)
 
-            if self._message_handler:
-                await self._message_handler(msg_obj, message)
-
+            # 先 ACK，让 RabbitMQ 确认投递成功
             await message.ack()
 
+            # 将 handler 投递到后台任务，不阻塞消费循环
+            if self._message_handler:
+                task = asyncio.create_task(
+                    self._safe_execute_handler(msg_obj, message)
+                )
+                self._running_tasks.add(task)
+                task.add_done_callback(self._running_tasks.discard)
+
         except json.JSONDecodeError as e:
-            # JSON解析失败，消息格式错误，记录日志并ACK（避免无限循环）
             logger.error(f"消息JSON解析失败，消息将被丢弃: {e}", exc_info=True)
             await message.ack()
         except Exception as e:
-            # 处理异常，记录日志并ACK（避免消息重复消费）
             logger.error(f"消息处理异常，消息将被丢弃: {e}", exc_info=True)
             await message.ack()
 
+    async def _safe_execute_handler(self, msg_obj: MQMsgModel, message: AbstractIncomingMessage):
+        """在 Semaphore 控制下安全执行 handler，支持异步和同步阻塞 handler"""
+        async with self._task_semaphore:
+            try:
+                if not self._message_handler:
+                    return
+                handler = self._message_handler
+                if inspect.iscoroutinefunction(handler):
+                    await handler(msg_obj, message)
+                else:
+                    # 同步阻塞 handler：丢进线程池，手动传递 traceId
+                    trace_id = msg_obj.traceId
+                    loop = asyncio.get_running_loop()
+
+                    def _sync_wrapper():
+                        SYLogger.set_trace_id(trace_id)
+                        try:
+                            return handler(msg_obj, message)
+                        finally:
+                            SYLogger.reset_trace_id(
+                                current_trace_id.set(None))
+
+                    await loop.run_in_executor(None, _sync_wrapper)
+            except Exception as e:
+                logger.error(f"异步任务执行失败: {e}", exc_info=True)
+
     async def start_consuming(self) -> Optional[ConsumerTag]:
         if self._closed:
             raise RuntimeError("客户端已关闭，无法启动消费")
@@ -391,6 +427,18 @@ class RabbitMQClient:
 
         await self.stop_consuming()
 
+        # 等待后台任务完成（优雅退出）
+        if self._running_tasks:
+            logger.info(f"等待 {len(self._running_tasks)} 个后台任务完成...")
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(*self._running_tasks, return_exceptions=True),
+                    timeout=15.0
+                )
+            except asyncio.TimeoutError:
+                logger.warning(f"等待后台任务超时，剩余 {len(self._running_tasks)} 个任务将被丢弃")
+            self._running_tasks.clear()
+
         if self._channel and not self._channel.is_closed:
             try:
                 await self._channel.close()

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -158,6 +158,7 @@ class RabbitMQClientManager(RabbitMQCoreService):
             auto_parse_json=kwargs.get('auto_parse_json', True),
             create_if_not_exists=create_if_not_exists,
             prefetch_count=kwargs.get('prefetch_count', 2),
+            max_concurrent_tasks=kwargs.get('max_concurrent_tasks', 5),
         )
 
         # 4. 连接客户端

{sycommon_python_lib-0.2.3a3 → sycommon_python_lib-0.2.3a5}/src/sycommon_python_lib.egg-info/PKG-INFO

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