agentengine-sdk-python 0.6.9__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/runners/patch_langchain.py

@@ -5,12 +5,6 @@ Monkey patch for langchain-openai to support reasoning_content field (e.g. for D
 import logging
 from typing import Any, Mapping, cast
 
-from ksadk.conversations.model_options import (
-    model_options_for_chat_completions,
-    model_options_for_responses,
-)
-from ksadk.runtime_context import get_current_invocation_context
-
 from langchain_core.messages import (
     AIMessageChunk,
     BaseMessageChunk,
@@ -22,6 +16,12 @@ from langchain_core.messages import (
 )
 from langchain_core.messages.tool import tool_call_chunk
 
+from ksadk.conversations.model_options import (
+    model_options_for_chat_completions,
+    model_options_for_responses,
+)
+from ksadk.runtime_context import get_current_invocation_context
+
 logger = logging.getLogger(__name__)
 
 # Original function reference (to avoid recursion if patched multiple times)
@@ -95,22 +95,22 @@ _original_chat_get_request_payload = None
 def _patched_convert_message_to_dict(message, *args, **kwargs):
     """Patched version to include reasoning_content in outgoing requests."""
     from langchain_core.messages import AIMessage
-    
+
     # Call original function first
     result = _original_convert_message_to_dict(message, *args, **kwargs)
-    
+
     # If this is an AIMessage with tool_calls and reasoning_content in additional_kwargs
     if isinstance(message, AIMessage):
-        additional_kwargs = getattr(message, 'additional_kwargs', {}) or {}
-        reasoning = additional_kwargs.get('reasoning_content')
-        
+        additional_kwargs = getattr(message, "additional_kwargs", {}) or {}
+        reasoning = additional_kwargs.get("reasoning_content")
+
         # Only add if we have tool_calls (required by some thinking models)
         if message.tool_calls and reasoning is not None:
-            result['reasoning_content'] = reasoning
+            result["reasoning_content"] = reasoning
         elif message.tool_calls and reasoning is None:
             # Force add empty reasoning_content for thinking models
-            result['reasoning_content'] = ''
-    
+            result["reasoning_content"] = ""
+
     return result
 
 
@@ -168,7 +168,7 @@ def apply_patch():
         # Patch 1: Fix receiving responses (capture reasoning_content)
         _original_convert_delta = base_module._convert_delta_to_message_chunk
         base_module._convert_delta_to_message_chunk = _patched_convert_delta_to_message_chunk
-        
+
         # Patch 2: Fix sending requests (include reasoning_content for tool_call messages)
         _original_convert_message_to_dict = base_module._convert_message_to_dict
         base_module._convert_message_to_dict = _patched_convert_message_to_dict
@@ -177,7 +177,7 @@ def apply_patch():
         base_module.BaseChatOpenAI._get_request_payload = _patched_base_get_request_payload
         _original_chat_get_request_payload = base_module.ChatOpenAI._get_request_payload
         base_module.ChatOpenAI._get_request_payload = _patched_chat_get_request_payload
-        
+
         base_module._ksadk_patched = True
 
         # logger.info("Applied langchain-openai patch for reasoning_content support")

ksadk/runners/remote_runner.py

@@ -1,7 +1,7 @@
 """
 RemoteRunner - 远程 Agent 运行时
 
-与 AgentTUI 配合使用，提供和本地 Runner 一致的接口
+与 InteractionLoop 配合使用，提供和本地 Runner 一致的接口
 """
 
 import json
@@ -43,6 +43,13 @@ class RemoteRunner(BaseRunner):
         self._agent = None  # 兼容 BaseRunner
         self._responses_tool_names: dict[str, str] = {}
         self._responses_tool_args: dict[str, str] = {}
+        self._responses_streamed_item_keys: set[str] = set()
+        self._responses_text_streamed = False
+        self._responses_reasoning_streamed = False
+        self._observed_model: str | None = None  # 流式回包里观察到的真实模型名
+        self.available_models: list[dict[str, Any]] | None = (
+            None  # ListAgentModels 拿到的可选模型列表
+        )
 
     @staticmethod
     def _normalize_api_format(api_format: Optional[str]) -> str:
@@ -107,19 +114,45 @@ class RemoteRunner(BaseRunner):
         return str(user_input or "")
 
     @staticmethod
-    def _build_responses_conversation_history(history: Any, current_input: Any) -> list[dict[str, Any]]:
-        if not isinstance(history, Sequence) or isinstance(
-            history, (str, bytes, bytearray)
-        ):
+    def _build_responses_conversation_history(
+        history: Any, current_input: Any
+    ) -> list[dict[str, Any]]:
+        if not isinstance(history, Sequence) or isinstance(history, (str, bytes, bytearray)):
             return []
 
         messages: list[dict[str, Any]] = []
+        current_output_call_ids: set[str] = set()
+        if isinstance(current_input, Mapping):
+            current_items = [current_input]
+        elif isinstance(current_input, Sequence) and not isinstance(
+            current_input, (str, bytes, bytearray)
+        ):
+            current_items = [item for item in current_input if isinstance(item, Mapping)]
+        else:
+            current_items = []
+        for item in current_items:
+            if str(item.get("type") or "").strip().lower() != "function_call_output":
+                continue
+            call_id = str(item.get("call_id") or "").strip()
+            if call_id:
+                current_output_call_ids.add(call_id)
         current_text = RemoteRunner._responses_message_text(
             {"role": "user", "content": current_input}
         ).strip()
         for item in history:
             if not isinstance(item, Mapping):
                 continue
+            item_type = str(item.get("type") or "").strip().lower()
+            if item_type in {"function_call", "function_call_output"}:
+                # Responses tool items are already protocol-shaped. Do not
+                # reinterpret them as chat messages or they lose call_id.
+                if (
+                    item_type == "function_call_output"
+                    and str(item.get("call_id") or "").strip() in current_output_call_ids
+                ):
+                    continue
+                messages.append(dict(item))
+                continue
             role = str(item.get("role") or "").strip().lower()
             if role == "model":
                 role = "assistant"
@@ -139,7 +172,9 @@ class RemoteRunner(BaseRunner):
         return messages
 
     @staticmethod
-    def _responses_conversation_name(input_data: Mapping[str, Any], session_id: Optional[str]) -> str:
+    def _responses_conversation_name(
+        input_data: Mapping[str, Any], session_id: Optional[str]
+    ) -> str:
         if not session_id:
             return ""
         platform_context = input_data.get("platform_context")
@@ -176,10 +211,27 @@ class RemoteRunner(BaseRunner):
                 "input": self._build_responses_input(user_input),
                 "stream": stream,
             }
-            history_enabled = bool(input_data.get("responses_conversation")) and not previous_response_id
+            history_enabled = (
+                bool(input_data.get("responses_conversation"))
+                or bool(input_data.get("responses_history"))
+            ) and not previous_response_id
             if history_enabled:
+                structured_history = input_data.get("responses_history")
+                history_input: Sequence[Any] | None
+                if isinstance(structured_history, Sequence) and not isinstance(
+                    structured_history, (str, bytes, bytearray)
+                ):
+                    history_input = structured_history
+                else:
+                    fallback_history = input_data.get("history")
+                    history_input = (
+                        fallback_history
+                        if isinstance(fallback_history, Sequence)
+                        and not isinstance(fallback_history, (str, bytes, bytearray))
+                        else None
+                    )
                 history = self._build_responses_conversation_history(
-                    input_data.get("history"),
+                    history_input,
                     user_input,
                 )
                 if history:
@@ -188,9 +240,7 @@ class RemoteRunner(BaseRunner):
             if conversation and not previous_response_id:
                 payload["conversation"] = conversation
             elif (
-                input_data.get("responses_conversation")
-                and session_id
-                and not previous_response_id
+                input_data.get("responses_conversation") and session_id and not previous_response_id
             ):
                 conversation = self._responses_conversation_name(input_data, str(session_id))
                 if conversation:
@@ -204,9 +254,15 @@ class RemoteRunner(BaseRunner):
         return payload
 
     @staticmethod
-    def _builtin_response_tool_schemas(input_data: Mapping[str, Any] | None = None) -> list[dict[str, Any]]:
+    def _builtin_response_tool_schemas(
+        input_data: Mapping[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
         try:
-            from ksadk.toolsets import builtin_tool_descriptors_for_runtime, builtin_tools_mode, describe_agentengine_tools
+            from ksadk.toolsets import (
+                builtin_tool_descriptors_for_runtime,
+                builtin_tools_mode,
+                describe_agentengine_tools,
+            )
 
             mode = builtin_tools_mode(default="off")
             descriptors = builtin_tool_descriptors_for_runtime(mode=mode)
@@ -215,7 +271,9 @@ class RemoteRunner(BaseRunner):
         deferred_names = RemoteRunner._deferred_tool_names(input_data)
         if deferred_names:
             try:
-                direct_descriptors = describe_agentengine_tools(include=deferred_names, profile="coding")
+                direct_descriptors = describe_agentengine_tools(
+                    include=deferred_names, profile="coding"
+                )
             except Exception:
                 direct_descriptors = []
             direct_descriptors = [
@@ -342,7 +400,9 @@ class RemoteRunner(BaseRunner):
         usage = self._response_usage_payload(data)
 
         if self.api_format == "responses":
-            result = {"output": self._extract_responses_output_text(data) or str(data)}
+            result: dict[str, Any] = {
+                "output": self._extract_responses_output_text(data) or str(data)
+            }
             if usage:
                 result["usage"] = usage
             return result
@@ -362,6 +422,14 @@ class RemoteRunner(BaseRunner):
         """流式调用远程 Agent"""
         import httpx
 
+        # 工具 item/call_id 只在单次 response 内有效。RemoteRunner 会被 TUI 多轮复用，
+        # 若保留上一轮的追踪状态，runtime 复用 id 时 response.completed 会被误判为重放。
+        self._responses_tool_names.clear()
+        self._responses_tool_args.clear()
+        self._responses_streamed_item_keys.clear()
+        self._responses_text_streamed = False
+        self._responses_reasoning_streamed = False
+
         user_input = input_data.get("input", "")
         session_id = input_data.get("session_id") or self.session_id
 
@@ -406,6 +474,17 @@ class RemoteRunner(BaseRunner):
                         try:
                             data = json.loads(data_str)
 
+                            # 记录回包里的真实模型名：
+                            # chat completions 顶层 data.model；responses 格式在
+                            # data.response.model（response.completed 事件的 response 对象）。
+                            observed = data.get("model") if isinstance(data, Mapping) else None
+                            if not observed and isinstance(data, Mapping):
+                                resp = data.get("response")
+                                if isinstance(resp, Mapping):
+                                    observed = resp.get("model")
+                            if observed and not isinstance(observed, (list, dict)):
+                                self._observed_model = str(observed)
+
                             if self.api_format == "responses":
                                 async for item in self._iter_responses_stream_events(
                                     data, event_name=event_name
@@ -413,11 +492,28 @@ class RemoteRunner(BaseRunner):
                                     yield item
                                 continue
 
+                            # 兜底：api_format 标成 chat 但 runtime 实发 responses 格式
+                            # 事件（event_name 或 data.type 以 response. 开头）→ 按 responses
+                            # 解析，否则 response.reasoning.delta 会被 chat 路径当顶层 text 显示。
+                            _ev = event_name or (
+                                str(data.get("type")) if isinstance(data, Mapping) else ""
+                            )
+                            if _ev.startswith("response."):
+                                async for item in self._iter_responses_stream_events(
+                                    data, event_name=event_name
+                                ):
+                                    yield item
+                                continue
+
                             # 解析 OpenAI Chat Completions 流式格式
                             choices = data.get("choices", [])
                             usage = data.get("usage")
                             if isinstance(usage, Mapping):
-                                yield {"type": "final", "usage": dict(usage)}
+                                final_chunk = {"type": "final", "usage": dict(usage)}
+                                metadata = data.get("metadata")
+                                if isinstance(metadata, Mapping):
+                                    final_chunk["metadata"] = dict(metadata)
+                                yield final_chunk
                                 final_sent = True
                             if choices:
                                 delta = choices[0].get("delta", {})
@@ -429,6 +525,13 @@ class RemoteRunner(BaseRunner):
                                 if content:
                                     accumulated_text += content
                                     yield {"delta": content, "type": "text"}
+                            else:
+                                # 非标准简化流（runtime 直发顶层 delta，无 choices 包装）：
+                                # 兜底提取顶层 delta 作为正文，与 _extract_content 口径一致。
+                                top_delta = data.get("delta")
+                                if isinstance(top_delta, str) and top_delta:
+                                    accumulated_text += top_delta
+                                    yield {"delta": top_delta, "type": "text"}
 
                         except json.JSONDecodeError:
                             pass
@@ -484,11 +587,14 @@ class RemoteRunner(BaseRunner):
     def _remember_responses_tool(
         self, key: str, item: Dict[str, Any], name: str, args: str
     ) -> None:
+        if key:
+            self._responses_streamed_item_keys.add(key)
         if key:
             self._responses_tool_names[key] = name
             self._responses_tool_args[key] = args
         call_id = str(item.get("call_id") or "")
         if call_id:
+            self._responses_streamed_item_keys.add(call_id)
             self._responses_tool_names[call_id] = name
             self._responses_tool_args[call_id] = args
 
@@ -526,6 +632,8 @@ class RemoteRunner(BaseRunner):
         data: Dict[str, Any],
         *,
         status: str,
+        replay_completed_text: bool = False,
+        replay_completed_reasoning: bool = False,
     ) -> AsyncIterator[Dict[str, Any]]:
         item = data.get("item") or data.get("output_item") or data
         if not isinstance(item, dict):
@@ -541,15 +649,31 @@ class RemoteRunner(BaseRunner):
                 else item.get("args", item.get("input"))
             )
             self._remember_responses_tool(key, item, name, args)
-            yield {"type": "tool_call", "tool_name": name, "tool_args": args, "status": status}
+            yield {
+                "type": "tool_call",
+                "tool_name": name,
+                "tool_args": args,
+                "status": status,
+                "call_id": key,
+            }
             return
 
         if item_type == "function_call_output":
             name = self._responses_tool_name(key, item)
+            if key:
+                self._responses_streamed_item_keys.add(key)
+            call_id = str(item.get("call_id") or "")
+            if call_id:
+                self._responses_streamed_item_keys.add(call_id)
             output = self._stringify_responses_payload(
                 item.get("output") if "output" in item else item.get("result", item.get("content"))
             )
-            yield {"type": "tool_result", "tool_name": name, "tool_output": output}
+            yield {
+                "type": "tool_result",
+                "tool_name": name,
+                "tool_output": output,
+                "call_id": call_id or key,
+            }
             return
 
         if item_type == "mcp_approval_request":
@@ -576,13 +700,15 @@ class RemoteRunner(BaseRunner):
 
         if item_type in {"reasoning", "reasoning_summary", "reasoning_summary_text"}:
             text = self._responses_item_text(item)
-            if text:
+            if text and (status != "completed" or replay_completed_reasoning):
+                self._responses_reasoning_streamed = True
                 yield {"delta": text, "type": "thinking"}
             return
 
         if item_type == "message":
             text = self._responses_item_text(item)
-            if text and status != "completed":
+            if text and (status != "completed" or replay_completed_text):
+                self._responses_text_streamed = True
                 yield {"delta": text, "type": "text"}
             return
 
@@ -596,6 +722,7 @@ class RemoteRunner(BaseRunner):
         if event_name == "response.reasoning.delta":
             delta = data.get("delta")
             if delta:
+                self._responses_reasoning_streamed = True
                 yield {"delta": str(delta), "type": "thinking"}
             return
         if event_type in {
@@ -606,12 +733,16 @@ class RemoteRunner(BaseRunner):
         }:
             delta = data.get("delta") or data.get("text")
             if delta:
+                self._responses_reasoning_streamed = True
                 yield {"delta": str(delta), "type": "thinking"}
             return
-        if event_type == "response.output_text.delta":
-            delta = data.get("delta")
-            if delta:
-                yield {"delta": str(delta), "type": "text"}
+        if event_type in {"response.output_text.delta", "response.output_text.done"}:
+            text = data.get("delta") or data.get("text")
+            if text and (
+                event_type == "response.output_text.delta" or not self._responses_text_streamed
+            ):
+                self._responses_text_streamed = True
+                yield {"delta": str(text), "type": "text"}
             return
         if event_type == "response.output_item.added":
             async for item in self._iter_responses_output_item(data, status="running"):
@@ -621,13 +752,51 @@ class RemoteRunner(BaseRunner):
             async for item in self._iter_responses_output_item(data, status="completed"):
                 yield item
             return
+        # ksadk/runtime 特有 tool 事件（对标 hosted UI responses-stream.js:176-186）
+        if event_type in {"response.tool_call", "response.ksadk.stage_tool_call"}:
+            name = str(data.get("name") or data.get("tool_name") or "tool")
+            args = self._stringify_responses_payload(
+                data.get("args") if "args" in data else data.get("arguments")
+            )
+            cid = str(data.get("call_id") or data.get("item_id") or data.get("run_id") or "")
+            yield {
+                "type": "tool_call",
+                "tool_name": name,
+                "tool_args": args,
+                "status": "running",
+                "call_id": cid,
+            }
+            return
+        if event_type in {
+            "response.tool_result",
+            "response.ksadk.tool_result",
+            "response.ksadk.stage_tool_result",
+        }:
+            name = str(data.get("name") or data.get("tool_name") or "tool")
+            output = self._stringify_responses_payload(
+                data.get("output") if "output" in data else data.get("result")
+            )
+            cid = str(data.get("call_id") or data.get("item_id") or data.get("run_id") or "")
+            yield {
+                "type": "tool_result",
+                "tool_name": name,
+                "tool_output": output,
+                "call_id": cid,
+            }
+            return
         if event_type == "response.function_call_arguments.delta":
             key = str(data.get("item_id") or data.get("call_id") or "")
             name = self._responses_tool_name(key, data)
             args = f"{self._responses_tool_args.get(key, '')}{str(data.get('delta') or '')}"
             if key:
                 self._responses_tool_args[key] = args
-            yield {"type": "tool_call", "tool_name": name, "tool_args": args, "status": "running"}
+            yield {
+                "type": "tool_call",
+                "tool_name": name,
+                "tool_args": args,
+                "status": "running",
+                "call_id": key,
+            }
             return
         if event_type == "response.function_call_arguments.done":
             key = str(data.get("item_id") or data.get("call_id") or "")
@@ -637,31 +806,88 @@ class RemoteRunner(BaseRunner):
             )
             if key:
                 self._responses_tool_args[key] = args
-            yield {"type": "tool_call", "tool_name": name, "tool_args": args, "status": "running"}
+            yield {
+                "type": "tool_call",
+                "tool_name": name,
+                "tool_args": args,
+                "status": "running",
+                "call_id": key,
+            }
             return
         if event_type == "response.completed":
-            response = data.get("response") if isinstance(data.get("response"), dict) else data
-            output = response.get("output") if isinstance(response, dict) else None
-            if isinstance(output, list):
+            nested_response = data.get("response")
+            response_data: dict[str, Any] = (
+                dict(nested_response) if isinstance(nested_response, dict) else data
+            )
+            completed_output = (
+                response_data.get("output") if isinstance(response_data, dict) else None
+            )
+            if isinstance(completed_output, list):
+                replayed_item_keys = set(self._responses_streamed_item_keys)
+                replay_completed_text = not self._responses_text_streamed
+                replay_completed_reasoning = not self._responses_reasoning_streamed
+                for item in completed_output:
+                    if isinstance(item, dict):
+                        key = self._responses_item_key(item, {"item": item})
+                        call_id = str(item.get("call_id") or "")
+                        if (key and key in replayed_item_keys) or (
+                            call_id and call_id in replayed_item_keys
+                        ):
+                            continue
+                        async for projected in self._iter_responses_output_item(
+                            {"item": item},
+                            status="completed",
+                            replay_completed_text=replay_completed_text,
+                            replay_completed_reasoning=replay_completed_reasoning,
+                        ):
+                            yield projected
                 chunk = {
                     "type": "responses_output",
-                    "output": output,
-                    "response_id": response.get("id"),
+                    "output": completed_output,
+                    "response_id": response_data.get("id"),
                 }
-                usage = response.get("usage")
+                usage = response_data.get("usage")
                 if isinstance(usage, Mapping):
                     chunk["usage"] = dict(usage)
+                metadata = response_data.get("metadata")
+                if isinstance(metadata, Mapping):
+                    chunk["metadata"] = dict(metadata)
                 yield chunk
             return
+        # response.content_part.delta：glm 等模型把 reasoning 走这个事件，
+        # partType 含 "reasoning" → thinking（不显示），否则 text（对标 hosted UI）。
+        if event_type == "response.content_part.delta":
+            part_value = data.get("part")
+            part: dict[str, Any] = dict(part_value) if isinstance(part_value, dict) else {}
+            delta = data.get("delta")
+            part_type = str(
+                part.get("type")
+                or (delta.get("type") if isinstance(delta, dict) else "")
+                or data.get("content_type")
+                or ""
+            )
+            text = ""
+            if isinstance(delta, dict):
+                text = str(delta.get("text") or delta.get("content") or "")
+            elif isinstance(delta, str):
+                text = delta
+            if not text:
+                text = str(data.get("text") or "")
+            if not text:
+                return
+            if "reasoning" in part_type:
+                self._responses_reasoning_streamed = True
+                yield {"delta": text, "type": "thinking"}
+            else:
+                self._responses_text_streamed = True
+                yield {"delta": text, "type": "text"}
+            return
         if event_type == "response.failed":
             yield {"type": "error", "message": self._responses_error_message(data)}
             return
         if event_type == "response.incomplete":
             yield {"type": "error", "message": "Agent 响应未完成"}
             return
-        if isinstance(data.get("delta"), str):
-            yield {"delta": str(data["delta"]), "type": "text"}
-            return
-        output_text = RemoteRunner._extract_responses_output_text(data)
-        if output_text and event_type != "response.completed":
-            yield {"delta": output_text, "type": "text"}
+        # 未知事件默认丢弃（对标 hosted UI responses-stream.js: 未知事件 return []）。
+        # 之前默认把 data.delta 当 text 显示，会导致 reasoning 走未识别事件时漏进正文。
+        # 正文已由 output_text.delta / content_part.delta 显式处理，未知事件不该当正文。

ksadk/runners/usage_accumulator.py

@@ -6,6 +6,7 @@ cached_tokens;Anthropic 经 langchain_anthropic 转换后 input_tokens 含 cache
 cache_creation),直接相加不重复;input_token_details 键名不统一(cached/cache_read/
 cache_creation),逐键求和作诊断明细。
 """
+
 from __future__ import annotations
 
 from typing import Any

ksadk/runners/utils/langfuse.py

@@ -157,7 +157,7 @@ def get_langfuse_callbacks() -> list[Any]:
     return callbacks
 
 
-def get_langfuse_metadata(session_id: str = None) -> dict:
+def get_langfuse_metadata(session_id: str | None = None) -> dict[str, Any]:
     """获取 Langfuse 的 metadata 字典
 
     通过 metadata 字段传递 trace 属性:
@@ -171,7 +171,7 @@ def get_langfuse_metadata(session_id: str = None) -> dict:
     Returns:
         包含 Langfuse 属性的 metadata 字典
     """
-    metadata = {}
+    metadata: dict[str, Any] = {}
 
     if session_id:
         metadata["langfuse_session_id"] = session_id
@@ -201,7 +201,7 @@ def get_langfuse_metadata(session_id: str = None) -> dict:
     return metadata
 
 
-def prepare_trace_metadata(session_id: str = None) -> tuple:
+def prepare_trace_metadata(session_id: str | None = None) -> tuple[Any, list[Any], Any, Any]:
     """准备 Trace 元数据
 
     Returns:

ksadk/runners/utils/loader.py

@@ -18,37 +18,37 @@ def load_agent_module(
     force_reload: bool = False,
 ) -> Any:
     """加载 Agent 模块
-    
+
     Args:
         project_dir: 项目目录
         entry_point: 入口文件 (e.g., "agent.py")
         agent_variable: Agent 变量名 (e.g., "root_agent", "graph")
-    
+
     Returns:
         加载的 Agent 对象
-    
+
     Raises:
         ImportError: 模块导入失败
         AttributeError: 未找到 Agent 变量
     """
     project_path = Path(project_dir).resolve()
-    
+
     # 添加项目目录到 Python 路径
     if str(project_path) not in sys.path:
         sys.path.insert(0, str(project_path))
     src_path = project_path / "src"
     if src_path.is_dir() and str(src_path) not in sys.path:
         sys.path.insert(0, str(src_path))
-    
+
     # 确定模块名
     if entry_point.endswith(".py"):
         module_name = entry_point[:-3]
     else:
         module_name = entry_point
-    
+
     # 路径转换为模块路径
     module_name = module_name.replace("/", ".").replace("\\", ".")
-    
+
     try:
         if force_reload and module_name in sys.modules:
             module = importlib.reload(sys.modules[module_name])