sycommon-python-lib 0.2.2a18__py3-none-any.whl → 0.2.3__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -51,6 +51,7 @@ from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
 from sycommon.middleware.background_execution import BackgroundExecutionMiddleware
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
+from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
@@ -107,7 +108,7 @@ class AgentConfig(BaseModel):
 
     # 沙箱配置
     sandbox_service_name: str = "shengye-platform-sandbox"
-    sandbox_timeout: int = 60
+    sandbox_timeout: int = 300
     skills_dir: Optional[str] = None
     memory_dir: Optional[str] = None
 
@@ -167,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 在流式场景可能拿不到）
@@ -210,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", [])
@@ -230,9 +238,32 @@ class DeepAgent:
                             f"[DeepAgent] AIMessage | content={repr(content_log)} | tools={tc_names}")
                     elif msg_type == "ToolMessage":
                         content_log = (msg.content or "")
-                        preview = content_log[:100]
-                        print(
-                            f"[DeepAgent] ToolResult | {getattr(msg, 'name', '?')} | len={len(content_log)} | preview={repr(preview)}")
+                        if isinstance(content_log, list):
+                            # e.g. [{'type': 'image', 'base64': '...'}]
+                            preview_parts = []
+                            total_len = 0
+                            for item in content_log:
+                                if isinstance(item, dict):
+                                    t = item.get('type', '?')
+                                    if t == 'image' and 'base64' in item:
+                                        b64 = item['base64']
+                                        total_len += len(b64)
+                                        preview_parts.append(
+                                            f"{{'type': 'image', 'base64': '{b64[:100]}...'({len(b64)} chars)}}")
+                                    else:
+                                        s = str(item)
+                                        total_len += len(s)
+                                        preview_parts.append(s[:100])
+                                else:
+                                    s = str(item)
+                                    total_len += len(s)
+                                    preview_parts.append(s[:100])
+                            print(
+                                f"[DeepAgent] ToolResult | {getattr(msg, 'name', '?')} | len={total_len} | preview={preview_parts}")
+                        else:
+                            preview = str(content_log)[:100]
+                            print(
+                                f"[DeepAgent] ToolResult | {getattr(msg, 'name', '?')} | len={len(str(content_log))} | preview={repr(preview)}")
                     elif msg_type == "HumanMessage":
                         content_log = (msg.content or "")[:100]
                         print(
@@ -373,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)
@@ -429,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:
@@ -484,11 +523,19 @@ 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
 
         last_error = None
+        sandbox_retries = 0
+        max_sandbox_retries = 3
 
         while True:
             for attempt in range(max_retries):
@@ -511,8 +558,9 @@ class DeepAgent:
                     else:
                         raise last_error
                 except RuntimeError as e:
-                    if "沙箱服务不可用" in str(e) and self.recovery_manager:
-                        SYLogger.warning("[DeepAgent] 沙箱服务不可用，尝试恢复...")
+                    if "沙箱服务不可用" in str(e) and self.recovery_manager and sandbox_retries < max_sandbox_retries:
+                        sandbox_retries += 1
+                        SYLogger.warning(f"[DeepAgent] 沙箱服务不可用，尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
                         recovered = await self.recovery_manager.recover()
                         if recovered:
                             SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
@@ -584,7 +632,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,
     )
@@ -598,6 +647,7 @@ async def create_deep_agent(
         "debug": config.debug,
         "middleware": [
             BackgroundExecutionMiddleware(backend=sandbox_backend),
+            ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             summarization_mw,
         ],

sycommon/agent/multi_agent_team.py

@@ -44,6 +44,7 @@ from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
 from sycommon.middleware.background_execution import BackgroundExecutionMiddleware
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
+from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
@@ -165,7 +166,7 @@ class TeamConfig(BaseModel):
     coordinator_name: str = "项目经理"
 
     sandbox_service_name: str = "shengye-platform-sandbox"
-    sandbox_timeout: int = 60
+    sandbox_timeout: int = 300
     skills_dir: Optional[str] = None
     memory_dir: Optional[str] = None
 
@@ -583,10 +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]
 
@@ -627,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],
@@ -640,8 +644,9 @@ async def create_multi_agent_team(
         name=coord_name,
         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),
+            coord_summarization_mw,
         ],
     )
 

sycommon/agent/sandbox/file_ops.py

@@ -266,8 +266,12 @@ class FileOperationsMixin:
                 "limit": limit
             }, timeout=timeout)
             if result.get("error"):
-                SYLogger.error(f"[Sandbox] 异步读取文件失败: {result['error']}")
-                return ReadResult(error=result["error"])
+                err_msg = result['error']
+                if 'not found' in err_msg:
+                    SYLogger.warning(f"[Sandbox] 异步读取文件未找到: {err_msg}")
+                else:
+                    SYLogger.error(f"[Sandbox] 异步读取文件失败: {err_msg}")
+                return ReadResult(error=err_msg)
             content = result.get("content", "")
             encoding = result.get("encoding", "utf-8")
             SYLogger.info(
@@ -329,7 +333,11 @@ class FileOperationsMixin:
                 path=result.get("path")
             )
             if write_result.error:
-                SYLogger.error(f"[Sandbox] 异步写入失败: {write_result.error}")
+                err_msg = write_result.error
+                if 'already exists' in err_msg:
+                    SYLogger.warning(f"[Sandbox] 异步写入文件已存在: {err_msg}")
+                else:
+                    SYLogger.error(f"[Sandbox] 异步写入失败: {err_msg}")
             else:
                 SYLogger.info(f"[Sandbox] 异步写入成功: {write_result.path}")
             return write_result

sycommon/agent/summarization_utils.py

@@ -1,46 +1,164 @@
 """上下文压缩 middleware 构建工具。
 
-根据 nacos 中配置的模型 maxTokens，用绝对 token 数设置压缩阈值，
-避免依赖模型 profile 信息（部分模型不提供 profile）。
+根据 nacos 中配置的模型 maxTokens，用绝对 token 数设置压缩阈值。
+优先使用模型 API 返回的 usage_metadata.total_tokens（真实 token 数），
+无 metadata 时回退到 chars_per_token=2.0 的估算值。
+同时增加基于消息数的安全阈值，防止估算偏低导致压缩不触发。
 """
 
 from __future__ import annotations
+import deepagents.middleware.summarization as _summ_mod
 
+import functools
+import logging
 from typing import TYPE_CHECKING
 
 from deepagents.middleware.summarization import (
     SummarizationMiddleware,
     SummarizationToolMiddleware,
 )
+from langchain_core.messages.utils import count_tokens_approximately
 
 if TYPE_CHECKING:
     from langchain_core.language_models import BaseChatModel
     from deepagents.backends.protocol import BACKEND_TYPES
 
+logger = logging.getLogger(__name__)
+
+
+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 阈值。
+
+    同时增加基于消息数的安全阈值：即使 token 估算偏低，
+    消息数超过 200 条时也会触发压缩（覆盖工具 schema 等未计入的开销）。
+    """
+    try:
+        from sycommon.config.Config import Config
+        model_name = getattr(model, 'model_name', None) or getattr(
+            model, 'model', None)
+        if model_name:
+            llm_cfg = Config().get_llm_config(model_name)
+            max_tokens = llm_cfg.get("maxTokens", 72000)
+        else:
+            max_tokens = 72000
+    except Exception:
+        max_tokens = 72000
+
+    # 60% 触发（120K/200K）：实测模型在 input≈137K 时开始退化，
+    # 在 120K 触发压缩留 ~17K 安全余量给工具 schema 等未计入开销
+    trigger = int(max_tokens * 0.60)
+    keep = int(max_tokens * 0.10)
+    return {
+        "trigger": [("tokens", trigger), ("messages", 200)],
+        "keep": ("tokens", keep),
+        "truncate_args_settings": {
+            "trigger": ("tokens", trigger),
+            "keep": ("tokens", keep),
+        },
+    }
+
+
+# monkey-patch：替换 deepagents 的默认计算函数
+_summ_mod.compute_summarization_defaults = _patched_compute_summarization_defaults
+
+# 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)
+    truncated_messages, _ = self._truncate_args(
+        effective_messages, request.system_message, request.tools,
+    )
+    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:
+        estimated = _approx_counter(counted_messages, tools=request.tools)
+    except TypeError:
+        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] 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
+
 
 def build_summarization_middleware(
     model: BaseChatModel,
     model_name: str,
     backend: "BACKEND_TYPES",
     *,
-    trigger_fraction: float = 0.85,
+    trigger_fraction: float = 0.60,
     keep_fraction: float = 0.10,
     default_max_tokens: int = 200000,
 ) -> SummarizationToolMiddleware:
-    """根据模型上下文窗口大小构建压缩 middleware。
+    """根据模型上下文窗口大小构建 compact_conversation 工具 middleware。
 
-    使用绝对 token 数而非 fraction 模式，避免要求模型提供 profile 信息。
+    优先使用模型返回的 usage_metadata 真实 token 数进行压缩判断，
+    无 usage_metadata 时回退到 chars_per_token=2.0 估算。
 
     Args:
         model: LLM 实例。
         model_name: 模型名称（用于从 nacos 读取配置）。
         backend: 后端实例。
-        trigger_fraction: 触发压缩的上下文窗口比例，默认 85%。
-        keep_fraction: 压缩后保留的上下文窗口比例，默认 10%。
+        trigger_fraction: 触发压缩占有效输入的比例，默认 60%。
+        keep_fraction: 压缩后保留占有效输入的比例，默认 10%。
         default_max_tokens: 无法从配置读取时的默认上下文窗口大小。
 
     Returns:
-        SummarizationToolMiddleware 实例（包含自动压缩 + compact_conversation 工具）。
+        SummarizationToolMiddleware 实例（提供 compact_conversation 工具）。
     """
     try:
         from sycommon.config.Config import Config
@@ -58,11 +176,17 @@ def build_summarization_middleware(
         backend=backend,
         trigger=("tokens", trigger_tokens),
         keep=("tokens", keep_tokens),
+        token_counter=functools.partial(
+            count_tokens_approximately, chars_per_token=2.0),
         trim_tokens_to_summarize=None,
         truncate_args_settings={
             "trigger": ("tokens", trigger_tokens),
             "keep": ("tokens", keep_tokens),
-            "max_length": 2000,
         },
     )
+
+    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/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/llm/get_llm.py

@@ -153,7 +153,7 @@ def get_llm(
 
     # 根据 wrap_structured 决定默认超时
     if timeout is _TIMEOUT_UNSET:
-        timeout = 180 if wrap_structured else None
+        timeout = 180 if wrap_structured else 300
 
     init_params = {
         "model_provider": llmConfig.provider,
@@ -165,9 +165,13 @@ def get_llm(
         "streaming": streaming,
         "timeout": timeout,
         "max_retries": max_retries,
-        "stream_chunk_timeout": None,
+        "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/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/llm/struct_token.py

@@ -345,7 +345,6 @@ class StructuredRunnableWithToken(Runnable):
             try:
                 with self.langfuse.start_as_current_observation(as_type="span", name="invoke") as span:
                     with propagate_attributes(session_id=trace_id, user_id=user_id):
-                        span.update_trace(user_id=user_id, session_id=trace_id)
                         return self._execute_chain(input, config, trace_id, user_id, span)
             except Exception as e:
                 # Langfuse 跟踪失败不应阻断业务，降级执行
@@ -366,7 +365,6 @@ class StructuredRunnableWithToken(Runnable):
             try:
                 with self.langfuse.start_as_current_observation(as_type="span", name="ainvoke") as span:
                     with propagate_attributes(session_id=trace_id, user_id=user_id):
-                        span.update_trace(user_id=user_id, session_id=trace_id)
                         return await self._aexecute_chain(input, config, trace_id, user_id, span)
             except Exception as e:
                 # Langfuse 跟踪失败不应阻断业务，降级执行
@@ -405,7 +403,7 @@ class StructuredRunnableWithToken(Runnable):
                 input_data = {"messages": adapted_input}
 
             if span:
-                span.update_trace(input=input_data)
+                span.update(input=input_data)
 
             structured_result = self.retry_chain.invoke(
                 input_data,
@@ -413,7 +411,7 @@ class StructuredRunnableWithToken(Runnable):
             )
 
             if span:
-                span.update_trace(output=structured_result)
+                span.update(output=structured_result)
 
             token_usage = token_handler.usage_metadata
             structured_result._token_usage_ = token_usage
@@ -447,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
@@ -465,7 +463,7 @@ class StructuredRunnableWithToken(Runnable):
                 input_data = {"messages": adapted_input}
 
             if span:
-                span.update_trace(input=input_data)
+                span.update(input=input_data)
 
             # 3. 调用子链
             structured_result = await self.retry_chain.ainvoke(
@@ -474,7 +472,7 @@ class StructuredRunnableWithToken(Runnable):
             )
 
             if span:
-                span.update_trace(output=structured_result)
+                span.update(output=structured_result)
 
             token_usage = token_handler.usage_metadata
             structured_result._token_usage_ = token_usage

sycommon/llm/sy_langfuse.py

@@ -3,11 +3,26 @@ from typing import Tuple, List, Optional, Any, Dict
 from langfuse import Langfuse, get_client
 from sycommon.config.Config import Config, SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
-from langfuse.langchain import CallbackHandler
+from langfuse.langchain import CallbackHandler as _LangfuseCallbackHandler
 from sycommon.tools.env import get_env_var
 from sycommon.tools.merge_headers import get_header_value
 
 
+class SafeLangfuseCallbackHandler(_LangfuseCallbackHandler):
+    """Wraps Langfuse CallbackHandler to handle unpicklable error objects.
+
+    LangGraph errors (e.g. Command/Interrupt dataclasses) may hold
+    _asyncio.Task references.  When Langfuse calls str(error) → asdict() →
+    deepcopy(), this raises TypeError: cannot pickle '_asyncio.Task' object.
+    """
+
+    def on_chain_error(self, error, **kwargs):
+        try:
+            super().on_chain_error(error, **kwargs)
+        except (TypeError, ValueError):
+            pass
+
+
 class LangfuseInitializer(metaclass=SingletonMeta):
     """
     Langfuse 初始化管理器
@@ -46,14 +61,14 @@ class LangfuseInitializer(metaclass=SingletonMeta):
                     'baseUrl', '')
                 os.environ["LANGFUSE_TRACING_ENVIRONMENT"] = environment
                 os.environ["OTEL_SERVICE_NAME"] = server_name
-                # 设置 OTLP 追踪导出器超时时间（单位：秒）
-                os.environ["OTEL_EXPORTER_OTLP_TRACES_TIMEOUT"] = "60"
-                # 全局 OTLP 超时（覆盖所有信号：追踪/指标/日志）
-                os.environ["OTEL_EXPORTER_OTLP_TIMEOUT"] = "60"
+                # 控制 Langfuse OTLP 导出：超时 30s、每批最多 32 个 span、每 10s 强制 flush
+                os.environ["LANGFUSE_TIMEOUT"] = "30"
+                os.environ["LANGFUSE_FLUSH_AT"] = "32"
+                os.environ["LANGFUSE_FLUSH_INTERVAL"] = "10"
 
                 self._langfuse_client = get_client()
 
-                langfuse_handler = CallbackHandler()
+                langfuse_handler = SafeLangfuseCallbackHandler()
                 self._base_callbacks.append(langfuse_handler)
 
                 SYLogger.info(f"Langfuse 初始化成功 [Service: {server_name}]")