sycommon-python-lib 0.2.3a10__tar.gz → 0.2.3a12__tar.gz

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/PKG-INFO

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

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/pyproject.toml

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

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/src/sycommon/agent/deep_agent.py

@@ -168,6 +168,7 @@ class DeepAgent:
         """
         current_tool_calls = []
         ai_chunk_buffer = ""
+        ai_text_content = ""
         seen_tool_call_ids = set()
         stream_step = 0
         # 兜底：累积流式 chunk 中的 usage_metadata（middleware 在流式场景可能拿不到）
@@ -211,6 +212,12 @@ class DeepAgent:
                         if usage_meta:
                             total_input_tokens += usage_meta.get("input_tokens", 0)
                             total_output_tokens += usage_meta.get("output_tokens", 0)
+                            if usage_meta.get("input_tokens", 0) > 0:
+                                SYLogger.debug(
+                                    f"[DeepAgent] usage_metadata | input={usage_meta.get('input_tokens', 0)} "
+                                    f"output={usage_meta.get('output_tokens', 0)} "
+                                    f"total={usage_meta.get('total_tokens', 0)} "
+                                    f"cumulative_input={total_input_tokens} step={stream_step}")
 
                     if msg_type == "AIMessageChunk":
                         tool_calls_log = getattr(msg, "tool_calls", [])
@@ -397,6 +404,7 @@ class DeepAgent:
 
                     if content:
                         ai_chunk_buffer += content
+                        ai_text_content += content
                         event = ChatEventBuilder.ai_chunk(
                             content, id=getattr(msg, "id", None),
                             agent=DEFAULT_AGENT_NAME)
@@ -453,6 +461,13 @@ class DeepAgent:
                 print(
                     f"[DeepAgent] AI chunk done | {repr(ai_chunk_buffer[:100])}...")
 
+            # 空响应检测：模型被调用但没有产出任何文本
+            if not ai_text_content and not ai_chunk_buffer:
+                SYLogger.warning(
+                    f"[DeepAgent] 空响应警告：模型未返回任何文本内容。"
+                    f"stream_step={stream_step}, tool_calls={len(current_tool_calls)}, "
+                    f"input_tokens={total_input_tokens}, output_tokens={total_output_tokens}")
+
             # 兜底：如果 middleware 没有成功记录（流式场景），在这里补充记录
             if total_input_tokens > 0 or total_output_tokens > 0:
                 try:
@@ -508,7 +523,13 @@ class DeepAgent:
         max_retries: int = 3,
         base_delay: float = 1.0,
     ) -> AsyncGenerator:
-        """带重试机制的 astream"""
+        """带重试机制的 astream
+
+        网络错误指数退避重试，BadRequestError 不重试。
+        上下文溢出由 deepagents SummarizationMiddleware 在模型调用层处理
+        （捕获 ContextOverflowError 后压缩消息并重试 LLM 调用），
+        不在此处重试整个 graph。
+        """
         import httpx
         from openai import APIConnectionError, APIError, APITimeoutError
 
@@ -529,11 +550,6 @@ class DeepAgent:
                     return
                 except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
                     last_error = e
-                    # 400 BadRequestError 不重试：请求参数有误，重试无意义
-                    from openai import BadRequestError
-                    if isinstance(e, BadRequestError):
-                        SYLogger.error(f"[DeepAgent] API 参数错误，不重试: {e}")
-                        raise
                     if attempt < max_retries - 1:
                         delay = base_delay * (2 ** attempt)
                         SYLogger.warning(

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/src/sycommon/agent/summarization_utils.py

@@ -1,8 +1,9 @@
 """上下文压缩 middleware 构建工具。
 
 根据 nacos 中配置的模型 maxTokens，用绝对 token 数设置压缩阈值。
-中文场景下 count_tokens_approximately 默认 chars_per_token=4.0 会低估约 2.1 倍，
-因此传入自定义 token_counter 修正偏差，并按真实 token 数设定阈值。
+优先使用模型 API 返回的 usage_metadata.total_tokens（真实 token 数），
+无 metadata 时回退到 chars_per_token=2.0 的估算值。
+同时增加基于消息数的安全阈值，防止估算偏低导致压缩不触发。
 """
 
 from __future__ import annotations
@@ -24,17 +25,28 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-# 中文场景修正：chars_per_token 从 4.0 改为 2.0，使近似计数接近真实 token 数
-_chinese_token_counter = functools.partial(
-    count_tokens_approximately, chars_per_token=2.0)
+
+def _extract_last_usage_total_tokens(messages) -> int:
+    """从消息历史中提取最后一条 AIMessage 的 usage_metadata.total_tokens。
+
+    返回 0 表示无数据（需回退到估算）。
+    """
+    from langchain_core.messages import AIMessage
+    for msg in reversed(messages):
+        if isinstance(msg, AIMessage):
+            meta = getattr(msg, 'usage_metadata', None)
+            if meta and isinstance(meta, dict):
+                total = meta.get('total_tokens', 0)
+                if isinstance(total, int) and total > 0:
+                    return total
+    return 0
 
 
 def _patched_compute_summarization_defaults(model):
     """覆盖 deepagents 默认值，返回中文场景修正后的绝对 token 阈值。
 
-    不走 fraction 路径（fraction 依赖 model.profile.max_input_tokens，
-    但内置 middleware 用默认 chars_per_token=4.0 计数，fraction 基于的基数不准）。
-    直接返回修正后的绝对 token 数。
+    同时增加基于消息数的安全阈值：即使 token 估算偏低，
+    消息数超过 200 条时也会触发压缩（覆盖工具 schema 等未计入的开销）。
     """
     try:
         from sycommon.config.Config import Config
@@ -48,10 +60,12 @@ def _patched_compute_summarization_defaults(model):
     except Exception:
         max_tokens = 72000
 
-    trigger = int(max_tokens * 0.70)
-    keep = int(max_tokens * 0.30)
+    # 60% 触发（120K/200K）：实测模型在 input≈137K 时开始退化，
+    # 在 120K 触发压缩留 ~17K 安全余量给工具 schema 等未计入开销
+    trigger = int(max_tokens * 0.60)
+    keep = int(max_tokens * 0.10)
     return {
-        "trigger": ("tokens", trigger),
+        "trigger": [("tokens", trigger), ("messages", 200)],
         "keep": ("tokens", keep),
         "truncate_args_settings": {
             "trigger": ("tokens", trigger),
@@ -63,10 +77,14 @@ def _patched_compute_summarization_defaults(model):
 # monkey-patch：替换 deepagents 的默认计算函数
 _summ_mod.compute_summarization_defaults = _patched_compute_summarization_defaults
 
-# monkey-patch：在内置 middleware 的 awrap_model_call 中注入日志
+# monkey-patch：在内置 middleware 的 awrap_model_call 中注入真实 token + 日志
 _OrigDeepAgentsSumm = _summ_mod._DeepAgentsSummarizationMiddleware
 _orig_awrap_model_call = _OrigDeepAgentsSumm.awrap_model_call
 
+# 基础估算函数，用于日志对比
+_approx_counter = functools.partial(
+    count_tokens_approximately, chars_per_token=2.0)
+
 
 async def _patched_awrap_model_call(self, request, handler):
     effective_messages = self._get_effective_messages(request)
@@ -75,15 +93,43 @@ async def _patched_awrap_model_call(self, request, handler):
     )
     counted_messages = [request.system_message, *
                         truncated_messages] if request.system_message is not None else truncated_messages
+
+    # 从截断前的 effective_messages 提取真实 token（截断会丢失 usage_metadata）
+    real_tokens = _extract_last_usage_total_tokens(effective_messages)
+
+    # 估算值（用于日志对比）
     try:
-        total_tokens = self.token_counter(
-            counted_messages, tools=request.tools)
+        estimated = _approx_counter(counted_messages, tools=request.tools)
     except TypeError:
-        total_tokens = self.token_counter(counted_messages)
-    should = self._should_summarize(truncated_messages, total_tokens)
+        estimated = _approx_counter(counted_messages)
+
+    # 如果有真实 token，临时替换 token_counter 使 _orig 内部判断也用真实值
+    # 这样 _should_summarize 和 _determine_cutoff_index 都能拿到正确的 token 数
+    if real_tokens > 0:
+        original_counter = self.token_counter
+
+        def _real_counter(msgs, **kwargs):
+            # 优先从当前消息中提取真实值（压缩后的消息可能有新的 metadata）
+            r = _extract_last_usage_total_tokens(msgs)
+            return r if r > 0 else real_tokens
+
+        self._lc_helper.token_counter = _real_counter
+        try:
+            result = await _orig_awrap_model_call(self, request, handler)
+        finally:
+            self._lc_helper.token_counter = original_counter
+    else:
+        result = await _orig_awrap_model_call(self, request, handler)
+
+    # 日志
+    source = 'real' if real_tokens > 0 else 'estimated'
+    should = self._should_summarize(truncated_messages, real_tokens if real_tokens > 0 else estimated)
     print(
-        f"[TokenCount] tokens={total_tokens} msgs={len(counted_messages)} should_summarize={should}")
-    return await _orig_awrap_model_call(self, request, handler)
+        f"[TokenCount] real={real_tokens} estimated={estimated} "
+        f"source={source} msgs={len(counted_messages)} "
+        f"should_summarize={should} "
+        f"trigger={getattr(self._lc_helper, 'trigger', '?')}")
+    return result
 
 
 _OrigDeepAgentsSumm.awrap_model_call = _patched_awrap_model_call
@@ -94,25 +140,21 @@ def build_summarization_middleware(
     model_name: str,
     backend: "BACKEND_TYPES",
     *,
-    trigger_fraction: float = 0.70,
-    keep_fraction: float = 0.30,
+    trigger_fraction: float = 0.60,
+    keep_fraction: float = 0.10,
     default_max_tokens: int = 200000,
 ) -> SummarizationToolMiddleware:
     """根据模型上下文窗口大小构建 compact_conversation 工具 middleware。
 
-    自动压缩由 deepagents 内置的 SummarizationMiddleware 处理，
-    它通过 model.profile.max_input_tokens（由 LLMWithTokenTracking 从 nacos 配置注入）
-    计算压缩阈值。
-
-    此处创建的 SummarizationToolMiddleware 仅提供 compact_conversation 手动压缩工具，
-    使用 nacos 配置的 maxTokens 作为其内部 SummarizationMiddleware 的阈值参数。
+    优先使用模型返回的 usage_metadata 真实 token 数进行压缩判断，
+    无 usage_metadata 时回退到 chars_per_token=2.0 估算。
 
     Args:
         model: LLM 实例。
         model_name: 模型名称（用于从 nacos 读取配置）。
         backend: 后端实例。
-        trigger_fraction: 触发压缩的上下文窗口比例，默认 70%。
-        keep_fraction: 压缩后保留的上下文窗口比例，默认 30%。
+        trigger_fraction: 触发压缩占有效输入的比例，默认 60%。
+        keep_fraction: 压缩后保留占有效输入的比例，默认 10%。
         default_max_tokens: 无法从配置读取时的默认上下文窗口大小。
 
     Returns:
@@ -134,7 +176,8 @@ def build_summarization_middleware(
         backend=backend,
         trigger=("tokens", trigger_tokens),
         keep=("tokens", keep_tokens),
-        token_counter=_chinese_token_counter,
+        token_counter=functools.partial(
+            count_tokens_approximately, chars_per_token=2.0),
         trim_tokens_to_summarize=None,
         truncate_args_settings={
             "trigger": ("tokens", trigger_tokens),
@@ -142,7 +185,8 @@ def build_summarization_middleware(
         },
     )
 
-    print(f"[Summarization] compact_conversation 工具配置: model={model_name}, max_tokens={max_tokens}, "
+    print(f"[Summarization] compact_conversation 工具配置: model={model_name}, "
+          f"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.3a10 → sycommon_python_lib-0.2.3a12}/src/sycommon/config/LLMConfig.py

@@ -11,6 +11,7 @@ class LLMConfig(BaseModel):
     callFunction: bool
     default: Optional[bool] = False
     apiKey: Optional[str] = None
+    maxOutputTokens: Optional[int] = None
 
     @classmethod
     def from_config(cls, model_name: str):

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/src/sycommon/llm/get_llm.py

@@ -1,3 +1,4 @@
+import os
 from sycommon.llm.llm_logger import LLMLogger
 from langchain.chat_models import init_chat_model
 from sycommon.config.LLMConfig import LLMConfig
@@ -159,7 +160,7 @@ def get_llm(
         "model_provider": llmConfig.provider,
         "model": llmConfig.model,
         "base_url": llmConfig.baseUrl,
-        "api_key": llmConfig.apiKey or "-",
+        "api_key": os.environ.get("LLM_API_KEY") or llmConfig.apiKey or "-",
         "callbacks": callbacks,
         "temperature": temperature,
         "streaming": streaming,
@@ -168,6 +169,10 @@ def get_llm(
         "stream_chunk_timeout": 180,
     }
 
+    # 传入 maxOutputTokens（max_completion_tokens）确保模型有足够的输出 token 空间
+    if llmConfig.maxOutputTokens:
+        init_params["max_tokens"] = llmConfig.maxOutputTokens
+
     # 合并其他透传参数（包括 presence_penalty, extra_body, top_p 等）
     init_params.update(kwargs)
 

{sycommon_python_lib-0.2.3a10 → sycommon_python_lib-0.2.3a12}/src/sycommon/llm/struct_token.py

@@ -445,10 +445,10 @@ class StructuredRunnableWithToken(Runnable):
 
             # 2. 检查并执行上下文压缩 (仅在异步模式且开启时)
             if self.enable_compression:
-                max_tokens = self.llmConfig.maxTokens
+                max_tokens = int(self.llmConfig.maxTokens * self.threshold_ratio)
                 current_tokens = self._count_tokens(adapted_input)
 
-                if current_tokens > max_tokens * self.threshold_ratio:
+                if current_tokens > max_tokens:
                     SYLogger.warning(
                         f"⚠️ Context limit reached: {current_tokens}/{max_tokens}")
                     # 执行压缩，替换 adapted_input