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

ksadk/common/llm_utils.py

@@ -1,7 +1,7 @@
 """LLM Utilities"""
 
-import os
 import logging
+import os
 
 logger = logging.getLogger(__name__)
 
@@ -10,28 +10,32 @@ PUBLIC_ENDPOINT = "https://kspmas.ksyun.com/v1/"
 
 # Internal Endpoint (Auto-injected by Platform)
 # Note: In most cases, we don't need to hardcode this because the platform injects it.
-# But for the purpose of "smart switching based on public URL", we might need to know what to switch TO, 
+# But for "smart switching based on public URL", we might need to know
+# what to switch TO,
 # or simply rely on leaving it empty so the platform default takes over?
-# 
+#
 # According to user: "OPENAI_BASE_URL 不填会自动选择的" (If empty, it auto-selects).
-# So our strategy: If Public URL + Internal Env -> Unset OPENAI_BASE_URL (letting it fall back to platform default).
+# Strategy: If Public URL + Internal Env -> Unset OPENAI_BASE_URL,
+# letting it fall back to the platform default.
+
 
 def get_smart_openai_env() -> None:
     """Smartly configure OpenAI Environment Variables.
-    
+
     If it detects that the code is running in a Ksyun Internal Environment (Serverless/KCE)
     AND the OPENAI_BASE_URL is set to the Public Endpoint, it will unset OPENAI_BASE_URL
     to allow the platform's automatic internal endpoint injection to take effect.
-    
-    This prevents network hangs caused by accessing public endpoints from internal-only environments.
+
+    This prevents network hangs caused by accessing public endpoints from
+    internal-only environments.
     """
     base_url = os.environ.get("OPENAI_BASE_URL", "").strip()
-    
+
     # logic 1: Check if it is the Public Endpoint
     # Normalize by removing trailing slash for comparison
     normalized_url = base_url.rstrip("/")
     normalized_public = PUBLIC_ENDPOINT.rstrip("/")
-    
+
     if normalized_url != normalized_public:
         return
 
@@ -41,11 +45,11 @@ def get_smart_openai_env() -> None:
     # - K_SERVICE (Injected by Knative/Serverless)
     # - KUBERNETES_SERVICE_HOST (Injected by K8s)
     is_internal = (
-        "KSYUN_REGION" in os.environ 
+        "KSYUN_REGION" in os.environ
         or "K_SERVICE" in os.environ
         or "KUBERNETES_SERVICE_HOST" in os.environ
     )
-    
+
     if is_internal:
         logger.warning(
             f"Detected Public OPENAI_BASE_URL ({base_url}) in Internal Environment. "
@@ -55,7 +59,7 @@ def get_smart_openai_env() -> None:
         # Or explicitly set it to internal generic address if known?
         # User said: "OPENAI_BASE_URL 不填会自动选择". So we unset it.
         del os.environ["OPENAI_BASE_URL"]
-        
+
         # Verify if successful removal
         if "OPENAI_BASE_URL" not in os.environ:
-             logger.info("Successfully switched to Internal Endpoint mode.")
+            logger.info("Successfully switched to Internal Endpoint mode.")

ksadk/compat/__init__.py

@@ -0,0 +1,5 @@
+"""兼容层包 (goal-00)。"""
+
+from ksadk.compat import adk_compat
+
+__all__ = ["adk_compat", "copilotkit_a2ui"]

ksadk/compat/adk_compat.py

@@ -0,0 +1,200 @@
+"""Google ADK 多版本兼容层 (goal-00)。
+
+ksadk 业务代码**不直接** ``import google.adk``;统一从本模块取符号。
+``google-adk`` 的版本差异只在兼容层内消化,业务代码对版本无感知。
+
+版本窗口
+--------
+依赖约束 ``google-adk>=1.34.0,<3.0.0``:
+
+- **1.34.x** 是最低支持锚点(不承诺 1.x 全系;1.0 缺 ``google.adk.apps`` 等,代价过大)。
+- **2.x**(当前 2.5.x)是上界内最新主线。
+
+实测(2026-07-21, goal-00 探测,解包对比 1.34.3 vs 2.5.0):ksadk 用到的
+全部符号在两个版本**都存在**,差异仅为 2.x 的**向后兼容可选新增**:
+
+- ``Runner.run_async`` 2.x 新增可选 ``yield_user_message``(默认 False)。
+- ``RunConfig`` 2.x 新增若干可选字段(``http_options`` / ``telemetry`` /
+  ``model_input_context`` 等),均为可选,不传不影响。
+- ``App.root_agent`` 2.x 变为可选(1.34 必填);ksadk 始终显式传,两版皆可。
+- ``DatabaseSessionService`` 2.x 新增可选 ``db_engine``(``db_url`` 变可选);
+  ksadk 始终传 ``db_url``,两版皆可。
+- ``McpToolset.header_provider`` 2.x 支持 awaitable;ksadk 未用该参数。
+
+ksadk 现有调用**不依赖任何 2.x-only 参数**,因此 1.34 与 2.x 对 ksadk 能力对等,
+无需降级 shim。能力降级矩阵的完整文字版见
+``docs/adk-multi-version-compat.md``。
+
+使用 2.x-only 新能力的纪律
+--------------------------
+若未来要用某个 2.x 才有的可选参数/符号,**必须**在本层用
+:func:`adk_version_at_least` 判断后再下发,并对 1.34 做显式降级;不允许业务
+代码自行 ``import google.adk`` 探测。
+
+加载语义
+--------
+本模块 import 自身**不触发** ``google.adk`` 导入(惰性,PEP 562
+``__getattr__``)。只有真正访问某个符号时才导入对应 ``google.adk`` 子模块;
+未安装 ``google-adk`` 时抛出带安装提示的 :class:`ImportError`,便于
+``memory/adk_tool`` 等调用方捕获并降级为原函数。
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _dist_version
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover - 仅供 mypy 静态检查,运行时不执行
+    pass
+
+#: 导出符号名 -> 提供该符号的 google.adk 子模块路径。
+#: 这是 ksadk 全部 google.adk 依赖的唯一登记表;新增依赖先在这里登记。
+_LAZY_SYMBOLS: dict[str, str] = {
+    # agents
+    "Agent": "google.adk.agents",
+    "RunConfig": "google.adk.agents.run_config",
+    "StreamingMode": "google.adk.agents.run_config",
+    # apps
+    "App": "google.adk.apps",
+    "ResumabilityConfig": "google.adk.apps",
+    # events
+    "Event": "google.adk.events.event",
+    # memory
+    "BaseMemoryService": "google.adk.memory.base_memory_service",
+    "SearchMemoryResponse": "google.adk.memory.base_memory_service",
+    "MemoryEntry": "google.adk.memory.memory_entry",
+    # models
+    "LlmResponse": "google.adk.models",
+    "LiteLlm": "google.adk.models.lite_llm",
+    # runners
+    "Runner": "google.adk.runners",
+    # sessions
+    "BaseSessionService": "google.adk.sessions",
+    "InMemorySessionService": "google.adk.sessions",
+    "Session": "google.adk.sessions",
+    "DatabaseSessionService": "google.adk.sessions",
+    "InvocationContext": "google.adk.agents",
+    "ToolContext": "google.adk.tools",
+    "GetSessionConfig": "google.adk.sessions.base_session_service",
+    "ListSessionsResponse": "google.adk.sessions.base_session_service",
+    # tools
+    "FunctionTool": "google.adk.tools",
+    "load_memory": "google.adk.tools",
+    "McpTool": "google.adk.tools.mcp_tool.mcp_tool",
+    "McpToolset": "google.adk.tools.mcp_tool.mcp_toolset",
+    "CheckableMcpHttpClientFactory": "google.adk.tools.mcp_tool.mcp_session_manager",
+    "StreamableHTTPConnectionParams": "google.adk.tools.mcp_tool.mcp_session_manager",
+}
+
+#: 以模块形式导出的名字 -> 模块路径(如 genai types、需要 monkeypatch 的 lite_llm)。
+_LAZY_MODULES: dict[str, str] = {
+    "genai_types": "google.genai.types",
+}
+
+_INSTALL_HINT = (
+    "google-adk 未安装或版本不在支持窗口 (>=1.34.0,<3.0.0)。" "安装: pip install 'ksadk[adk]'"
+)
+
+_ADK_NOT_FOUND = "google-adk 未安装"
+
+
+def _raise_missing(name: str, exc: BaseException) -> None:
+    raise ImportError(f"无法导入 google.adk 符号 {name!r}。{_INSTALL_HINT}") from exc
+
+
+def __getattr__(name: str) -> Any:
+    """PEP 562 惰性解析:首次访问符号时才导入对应 google.adk 子模块。"""
+    if name in _LAZY_SYMBOLS:
+        module_path = _LAZY_SYMBOLS[name]
+        try:
+            module = import_module(module_path)
+        except ImportError as exc:
+            _raise_missing(name, exc)
+        try:
+            value = getattr(module, name)
+        except AttributeError as exc:
+            raise ImportError(
+                f"google.adk 已安装但 {module_path} 缺少 {name!r};"
+                f"当前版本 {adk_version() or '未知'} 可能不在支持窗口 (>=1.34.0,<3.0.0)。"
+            ) from exc
+        # 注意: 刻意不缓存到 globals()。测试常 monkeypatch ``google.adk.*``
+        # 子模块符号(如把 Runner 换成 FakeRunner);若在此缓存,会把某次 patch
+        # 后的值泄漏给后续解析,造成跨测试污染。每次经 getattr 重新解析,
+        # 让既有 ``google.adk.*`` patch 点继续生效。开销可忽略(import_module
+        # 命中 sys.modules 缓存)。
+        return value
+    if name in _LAZY_MODULES:
+        module_path = _LAZY_MODULES[name]
+        try:
+            value = import_module(module_path)
+        except ImportError as exc:
+            _raise_missing(name, exc)
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY_SYMBOLS) | set(_LAZY_MODULES))
+
+
+def is_adk_available() -> bool:
+    """google-adk 是否可导入(不关心版本)。"""
+    try:
+        import_module("google.adk")
+    except ImportError:
+        return False
+    return True
+
+
+def adk_version() -> str | None:
+    """返回已安装的 google-adk 版本;未安装返回 None。"""
+    try:
+        return _dist_version("google-adk")
+    except PackageNotFoundError:
+        return None
+
+
+def adk_version_at_least(min_version: str) -> bool:
+    """已安装 google-adk 版本是否 >= ``min_version``;未安装或无法解析返回 False。
+
+    用于下发 2.x-only 能力前的版本门禁,例如::
+
+        if adk_version_at_least("2.0.0"):
+            kwargs["yield_user_message"] = True
+    """
+    ver = adk_version()
+    if ver is None:
+        return False
+    try:
+        from packaging.version import Version
+
+        return bool(Version(ver) >= Version(min_version))
+    except Exception:
+        return False
+
+
+def lite_llm_module() -> Any:
+    """返回 ``google.adk.models.lite_llm`` 模块对象。
+
+    adk_runner 的 JSON 容错 patch 需要 MonkeyPatch 该模块内的
+    ``_message_to_generate_content_response``(私有函数),因此需要模块本身
+    而非单个符号。未安装 litellm/google-adk 时抛 :class:`ImportError`。
+    """
+    try:
+        return import_module("google.adk.models.lite_llm")
+    except ImportError as exc:
+        _raise_missing("google.adk.models.lite_llm", exc)
+
+
+__all__ = [
+    # 版本/能力探测
+    "is_adk_available",
+    "adk_version",
+    "adk_version_at_least",
+    "lite_llm_module",
+    # 惰性符号
+    *_LAZY_SYMBOLS.keys(),
+    *_LAZY_MODULES.keys(),
+]

ksadk/compat/copilotkit_a2ui.py

@@ -0,0 +1,330 @@
+"""Compatibility bridge for the pinned CopilotKit and AG-UI A2UI packages.
+
+The currently pinned public packages disagree on the A2UI factory signature.
+More importantly, the released LangGraph adapter moves an async model invocation
+to a worker thread and calls it with ``asyncio.run``.  Async providers such as
+``ChatOpenAI`` retain event-loop-bound clients, so that path can wait forever.
+
+This module keeps CopilotKit's middleware lifecycle and dynamic-tool dispatch,
+but owns the small framework glue that invokes the A2UI sub-agent on the active
+event loop.  The A2UI wire format, prompt construction, and validation are still
+provided by the official AG-UI toolkit.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+import os
+from importlib import import_module
+from typing import Any
+
+try:
+    from copilotkit import CopilotKitMiddleware, copilotkit_lg_middleware
+    from langchain.tools import ToolRuntime, tool
+    from langchain_core.messages import SystemMessage
+except ImportError as exc:  # The module itself belongs to the optional AG-UI feature.
+    raise ImportError(
+        "CopilotKit A2UI requires ksadk[agui] with copilotkit and ag-ui-langgraph installed."
+    ) from exc
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_GENERATION_TIMEOUT_SECONDS = 20.0
+
+# The upstream toolkit's generic default prompt is intentionally exhaustive.
+# It is also large enough to exceed the Hosted UI model gateway's reliable tool
+# latency. This compact contract covers the v0.9 basic catalog used by ksadk-web
+# while leaving applications free to pass their own guidelines explicitly.
+_KSADK_HOSTED_UI_GUIDELINES = {
+    "generation_guidelines": """\
+Return exactly one render_a2ui tool call. Use A2UI v0.9 flat components: every
+component has an id and a component field. The root id is root. Use only Text,
+Column, Row, Card, List, Button, ChoicePicker, Divider, TextField, CheckBox,
+or Slider. Put properties directly on each component, never under type or
+properties. Use child for one component id and children for an array of ids.
+For example: [{\"id\":\"root\",\"component\":\"Card\",\"child\":\"content\"},
+{\"id\":\"content\",\"component\":\"Column\",\"children\":[\"title\"]},
+{\"id\":\"title\",\"component\":\"Text\",\"variant\":\"h2\",\"text\":\"Status\"}].
+Use only facts present in the conversation and tool results. Do not return
+Markdown or prose instead of the tool call.""",
+    "design_guidelines": """\
+Create one compact, readable surface. Use hierarchy and spacing through Card,
+Column, Row, Text, Divider, and ChoicePicker instead of decorative elements.
+For status, summarize real values; for risks, show severity and owner; for
+choices, use ChoicePicker with a bound data value.""",
+}
+
+
+def _a2ui_toolkit_dependencies() -> tuple[Any, ...]:
+    """Resolve the optional toolkit, which currently publishes no type metadata."""
+    try:
+        toolkit = import_module("ag_ui_a2ui_toolkit")
+    except ImportError as exc:
+        raise ImportError(
+            "CopilotKit A2UI requires ksadk[agui] with ag-ui-a2ui-toolkit installed."
+        ) from exc
+    names = (
+        "RENDER_A2UI_TOOL_DEF",
+        "resolve_a2ui_tool_params",
+        "prepare_a2ui_request",
+        "build_a2ui_envelope",
+        "validate_a2ui_components",
+        "augment_prompt_with_validation_errors",
+        "wrap_error_envelope",
+        "MAX_A2UI_ATTEMPTS",
+    )
+    values = tuple(getattr(toolkit, name, None) for name in names)
+    if any(value is None for value in values):
+        raise RuntimeError("ag-ui-a2ui-toolkit is missing a required A2UI integration symbol")
+    return values
+
+
+(
+    _RENDER_A2UI_TOOL_DEF,
+    _resolve_a2ui_tool_params,
+    _prepare_a2ui_request,
+    _build_a2ui_envelope,
+    _validate_a2ui_components,
+    _augment_prompt_with_validation_errors,
+    _wrap_error_envelope,
+    _MAX_A2UI_ATTEMPTS,
+) = _a2ui_toolkit_dependencies()
+
+
+def _generation_timeout_seconds() -> float:
+    """Read the operator-owned A2UI deadline, with a conservative default."""
+    raw = os.getenv("KSADK_A2UI_GENERATION_TIMEOUT_SECONDS", "").strip()
+    if not raw:
+        return _DEFAULT_GENERATION_TIMEOUT_SECONDS
+    try:
+        return max(1.0, min(float(raw), 120.0))
+    except ValueError:
+        return _DEFAULT_GENERATION_TIMEOUT_SECONDS
+
+
+def _tool_call_args(response: Any) -> dict[str, Any] | None:
+    for call in getattr(response, "tool_calls", None) or []:
+        if not isinstance(call, dict):
+            continue
+        if call.get("name") != _RENDER_A2UI_TOOL_DEF["function"]["name"]:
+            continue
+        args = call.get("args")
+        return args if isinstance(args, dict) else {}
+    return None
+
+
+async def _invoke_a2ui_subagent(
+    model_with_tool: Any,
+    *,
+    prompt: str,
+    messages: list[Any],
+    timeout_seconds: float,
+) -> dict[str, Any] | None:
+    """Ask the structured-output model on the same loop as the parent run."""
+
+    async def invoke() -> Any:
+        ainvoke = getattr(model_with_tool, "ainvoke", None)
+        if callable(ainvoke):
+            result = ainvoke([SystemMessage(content=prompt), *messages])
+            return await result if inspect.isawaitable(result) else result
+        invoke_sync = getattr(model_with_tool, "invoke", None)
+        if not callable(invoke_sync):
+            raise TypeError("A2UI model must expose ainvoke() or invoke()")
+        return await asyncio.to_thread(invoke_sync, [SystemMessage(content=prompt), *messages])
+
+    response = await asyncio.wait_for(invoke(), timeout=timeout_seconds)
+    return _tool_call_args(response)
+
+
+def _attempt_callback(callback: Any, record: dict[str, Any]) -> None:
+    if not callable(callback):
+        return
+    try:
+        callback(record)
+    except Exception:
+        # Diagnostics must not prevent a usable UI surface from being returned.
+        logger.debug("A2UI attempt callback failed", exc_info=True)
+
+
+async def _generate_a2ui_envelope(
+    *,
+    config: dict[str, Any],
+    state: dict[str, Any],
+    messages: list[Any],
+    intent: str,
+    target_surface_id: str | None,
+    changes: str | None,
+) -> str:
+    """Run the official validate/retry contract without crossing event loops."""
+
+    prep = _prepare_a2ui_request(
+        intent=intent,
+        target_surface_id=target_surface_id,
+        changes=changes,
+        messages=messages,
+        state=state,
+        guidelines=config["guidelines"],
+    )
+    if prep.get("error"):
+        return str(_wrap_error_envelope(prep["error"]))
+
+    model = config["model"]
+    model_with_tool = model.bind_tools(
+        [_RENDER_A2UI_TOOL_DEF],
+        tool_choice=_RENDER_A2UI_TOOL_DEF["function"]["name"],
+    )
+    recovery = config.get("recovery") or {}
+    max_attempts = recovery.get("maxAttempts", _MAX_A2UI_ATTEMPTS)
+    try:
+        max_attempts = max(1, min(int(max_attempts), 5))
+    except (TypeError, ValueError):
+        max_attempts = _MAX_A2UI_ATTEMPTS
+
+    timeout_seconds = _generation_timeout_seconds()
+    last_errors: list[dict[str, str]] = []
+    attempts: list[dict[str, Any]] = []
+    for attempt in range(1, max_attempts + 1):
+        prompt = _augment_prompt_with_validation_errors(prep["prompt"], last_errors)
+        try:
+            args = await _invoke_a2ui_subagent(
+                model_with_tool,
+                prompt=prompt,
+                messages=messages,
+                timeout_seconds=timeout_seconds,
+            )
+        except asyncio.TimeoutError:
+            record: dict[str, Any] = {
+                "attempt": attempt,
+                "ok": False,
+                "errors": [
+                    {
+                        "code": "a2ui_generation_timeout",
+                        "path": "model",
+                        "message": f"A2UI generation exceeded {timeout_seconds:g} seconds",
+                    }
+                ],
+            }
+            attempts.append(record)
+            _attempt_callback(config.get("on_a2ui_attempt"), record)
+            # Retrying an already-cancelled request usually piles up more work;
+            # return a visible error instead of leaving the chat in limbo.
+            return str(_wrap_error_envelope(record["errors"][0]["message"]))
+        except Exception as exc:
+            record = {
+                "attempt": attempt,
+                "ok": False,
+                "errors": [
+                    {
+                        "code": "a2ui_generation_error",
+                        "path": "model",
+                        "message": str(exc) or type(exc).__name__,
+                    }
+                ],
+            }
+            attempts.append(record)
+            _attempt_callback(config.get("on_a2ui_attempt"), record)
+            return str(_wrap_error_envelope(record["errors"][0]["message"]))
+
+        if not args:
+            record = {
+                "attempt": attempt,
+                "ok": False,
+                "errors": [
+                    {
+                        "code": "empty_components",
+                        "path": "components",
+                        "message": "Sub-agent did not call render_a2ui",
+                    }
+                ],
+            }
+        else:
+            components = args.get("components")
+            data = args.get("data")
+            validation = _validate_a2ui_components(
+                components=components if isinstance(components, list) else [],
+                data=data if isinstance(data, dict) else {},
+                catalog=config.get("catalog"),
+            )
+            record = {
+                "attempt": attempt,
+                "ok": bool(validation["valid"]),
+                "errors": list(validation["errors"]),
+            }
+        attempts.append(record)
+        _attempt_callback(config.get("on_a2ui_attempt"), record)
+        if record["ok"]:
+            return str(
+                _build_a2ui_envelope(
+                    args=args,
+                    is_update=prep["is_update"],
+                    target_surface_id=target_surface_id,
+                    prior=prep["prior"],
+                    default_surface_id=config["default_surface_id"],
+                    default_catalog_id=config["default_catalog_id"],
+                )
+            )
+        last_errors = record["errors"]
+
+    return str(
+        _wrap_error_envelope(f"Failed to generate valid A2UI after {max_attempts} attempt(s)")
+    )
+
+
+def build_ksadk_a2ui_tool(params: dict[str, Any]) -> Any:
+    """Build the dynamic LangChain A2UI tool used by the CopilotKit shim."""
+
+    resolved_params = dict(params)
+    resolved_params.setdefault("guidelines", _KSADK_HOSTED_UI_GUIDELINES)
+    config = _resolve_a2ui_tool_params(resolved_params)
+
+    @tool(config["tool_name"], description=config["tool_description"])
+    async def generate_a2ui(
+        runtime: ToolRuntime[Any],
+        intent: str = "create",
+        target_surface_id: str | None = None,
+        changes: str | None = None,
+    ) -> str:
+        state = runtime.state if isinstance(runtime.state, dict) else {}
+        messages = list(state.get("messages") or [])[:-1]
+        return await _generate_a2ui_envelope(
+            config=config,
+            state=state,
+            messages=messages,
+            intent=intent,
+            target_surface_id=target_surface_id,
+            changes=changes,
+        )
+
+    return generate_a2ui
+
+
+class KsadkCopilotKitMiddleware(CopilotKitMiddleware):
+    """Official lifecycle middleware with KSADK's safe A2UI tool executor."""
+
+    def _maybe_build_a2ui_tool(self, request: Any) -> Any | None:
+        state = request.state or {}
+        if not self._a2ui_inject_decision(state):
+            return None
+
+        resolved = self._resolve_a2ui_catalog(state)
+        _component_schema, catalog_id = resolved if resolved else (None, None)
+        params: dict[str, Any] = {"model": request.model}
+        if catalog_id:
+            params["default_catalog_id"] = catalog_id
+
+        tool = build_ksadk_a2ui_tool(params)
+        existing_names = {getattr(item, "name", None) for item in (request.tools or [])}
+        if tool.name in existing_names:
+            return None
+
+        thread_key = (
+            copilotkit_lg_middleware._current_thread_id()
+            or copilotkit_lg_middleware._DEFAULT_THREAD_KEY
+        )
+        copilotkit_lg_middleware._a2ui_tools_by_thread[thread_key] = tool
+        return tool
+
+
+__all__ = ["KsadkCopilotKitMiddleware", "build_ksadk_a2ui_tool"]

ksadk/configs/__init__.py

@@ -5,7 +5,7 @@ AgentEngine 统一配置管理
 
 使用方式:
     from ksadk.configs import settings
-    
+
 环境变量优先级 (举例):
     Model:    OPENAI_API_KEY > LLM_API_KEY > MODEL_API_KEY
     Langfuse: LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_HOST
@@ -17,24 +17,24 @@ AgentEngine 统一配置管理
 """
 
 from ksadk.configs.settings import (
-    # 全局配置入口
-    settings,
-    Settings,
-    # 各配置类
-    ModelConfig,
-    LangfuseConfig,
+    DEFAULT_MODEL_NAME,
+    KSPMAS_INTERNAL_HOST,
+    KSPMAS_INTERNAL_URL,
+    KSPMAS_PUBLIC_URL,
     AgentConfig,
-    KingsoftCloudConfig,
     CodeModeConfig,
+    KingsoftCloudConfig,
+    LangfuseConfig,
+    # 各配置类
+    ModelConfig,
     OTelConfig,
+    Settings,
     # 通用网络检测工具
     check_endpoint_reachable,
     # KSPMAS 服务
     get_kspmas_api_base,
-    KSPMAS_INTERNAL_HOST,
-    KSPMAS_INTERNAL_URL,
-    KSPMAS_PUBLIC_URL,
-    DEFAULT_MODEL_NAME,
+    # 全局配置入口
+    settings,
     setup_environment,
 )