@qingflow-tech/qingflow-cli 1.1.39 → 1.1.41

package/src/qingflow_mcp/tools/approval_tools.py

@@ -9,7 +9,7 @@ from ..config import DEFAULT_PROFILE
 from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error, message_looks_like_invalid_token, raise_tool_error
 from ..json_types import JSONObject
 from ..list_type_labels import get_record_list_type_label
-from .base import ToolBase, tool_cn_name
+from .base import ToolBase
 
 
 class ApprovalTools(ToolBase):
@@ -149,7 +149,6 @@ class ApprovalTools(ToolBase):
                 keyword=keyword,
             )
 
-    @tool_cn_name("写评论")
     def record_comment_write(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         raw = self.record_comment_add(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
@@ -160,7 +159,6 @@ class ApprovalTools(ToolBase):
             selection={},
         )
 
-    @tool_cn_name("评论提及")
     def record_comment_mentions(
         self,
         *,
@@ -207,7 +205,6 @@ class ApprovalTools(ToolBase):
             selection=selection,
         )
 
-    @tool_cn_name("任务通过")
     def task_approve(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行任务相关逻辑。"""
         if fields:
@@ -229,7 +226,6 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    @tool_cn_name("任务拒绝")
     def task_reject(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行任务相关逻辑。"""
         if fields:
@@ -251,7 +247,6 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    @tool_cn_name("任务退回候选")
     def task_rollback_candidates(self, *, profile: str, app_key: str, record_id: int, workflow_node_id: int) -> dict[str, Any]:
         """执行任务相关逻辑。"""
         selection = {"app_key": app_key, "record_id": record_id, "workflow_node_id": workflow_node_id}
@@ -274,7 +269,6 @@ class ApprovalTools(ToolBase):
             selection=selection,
         )
 
-    @tool_cn_name("任务退回")
     def task_rollback(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行任务相关逻辑。"""
         if fields:
@@ -296,7 +290,6 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    @tool_cn_name("任务转交")
     def task_transfer(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行任务相关逻辑。"""
         if fields:
@@ -319,7 +312,6 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    @tool_cn_name("任务仅保存")
     def task_save_only(
         self,
         *,
@@ -341,7 +333,6 @@ class ApprovalTools(ToolBase):
             workflow_node_id=workflow_node_id,
         )
 
-    @tool_cn_name("任务转交候选")
     def task_transfer_candidates(
         self,
         *,
@@ -390,7 +381,6 @@ class ApprovalTools(ToolBase):
             selection=selection,
         )
 
-    @tool_cn_name("新增评论")
     def record_comment_add(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -407,9 +397,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='新增评论')
 
-    @tool_cn_name("评论列表")
     def record_comment_list(self, *, profile: str, app_key: str, apply_id: int, page_size: int = 20, list_type: int | None = None, page_num: int | None = 1) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -432,7 +421,7 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        raw = self._run(profile, runner)
+        raw = self._run(profile, runner, tool_name='评论列表')
         items = _approval_page_items(raw.get("page"))
         return self._public_page_response(
             raw,
@@ -447,7 +436,6 @@ class ApprovalTools(ToolBase):
             selection={"app_key": app_key, "record_id": apply_id, "list_type": list_type},
         )
 
-    @tool_cn_name("评论提及候选")
     def record_comment_mention_candidates(
         self,
         *,
@@ -480,9 +468,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='评论提及候选')
 
-    @tool_cn_name("评论标记已读")
     def record_comment_mark_read(self, *, profile: str, app_key: str, apply_id: int) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -498,7 +485,7 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        raw = self._run(profile, runner)
+        raw = self._run(profile, runner, tool_name='评论标记已读')
         return self._public_action_response(
             raw,
             action="record_comment_mark_read",
@@ -506,7 +493,6 @@ class ApprovalTools(ToolBase):
             selection={},
         )
 
-    @tool_cn_name("评论统计")
     def record_comment_stats(self, *, profile: str, app_key: str, apply_id: int) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -522,9 +508,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='评论统计')
 
-    @tool_cn_name("记录通过")
     def record_approve(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -544,9 +529,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录通过')
 
-    @tool_cn_name("记录拒绝")
     def record_reject(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -566,9 +550,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录拒绝')
 
-    @tool_cn_name("记录退回候选")
     def record_rollback_candidates(self, *, profile: str, app_key: str, apply_id: int, audit_node_id: int) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -591,9 +574,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录退回候选')
 
-    @tool_cn_name("记录退回")
     def record_rollback(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -611,9 +593,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录退回')
 
-    @tool_cn_name("记录转交")
     def record_transfer(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -631,9 +612,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录转交')
 
-    @tool_cn_name("记录转交候选")
     def record_transfer_candidates(
         self,
         *,
@@ -664,9 +644,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录转交候选')
 
-    @tool_cn_name("记录改派信息")
     def record_reassign_get(self, *, profile: str, app_key: str, apply_id: int) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -682,9 +661,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录改派信息')
 
-    @tool_cn_name("记录改派")
     def record_reassign(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -701,9 +679,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='记录改派')
 
-    @tool_cn_name("会签候选")
     def record_countersign_candidates(
         self,
         *,
@@ -734,9 +711,8 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='会签候选')
 
-    @tool_cn_name("会签")
     def record_countersign(self, *, profile: str, app_key: str, apply_id: int, payload: dict[str, Any]) -> dict[str, Any]:
         """执行记录相关逻辑。"""
         self._require_app_and_apply(app_key, apply_id)
@@ -754,7 +730,7 @@ class ApprovalTools(ToolBase):
                 "request_route": self._request_route_payload(context),
             }
 
-        return self._run(profile, runner)
+        return self._run(profile, runner, tool_name='会签')
 
     def _request_route_payload(self, context) -> JSONObject:  # type: ignore[no-untyped-def]
         """执行内部辅助逻辑。"""

package/src/qingflow_mcp/tools/auth_tools.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import json
-from typing import Any
 import os
+from typing import Any
 
 from mcp.server.fastmcp import FastMCP
 
@@ -17,7 +17,7 @@ from ..config import (
 )
 from ..errors import QingflowApiError, backend_code_int, is_auth_like_error, raise_tool_error
 from ..session_store import SessionStore
-from .base import ToolBase, tool_cn_name
+from .base import ToolBase
 
 
 class AuthTools(ToolBase):
@@ -75,7 +75,6 @@ class AuthTools(ToolBase):
         def auth_logout(profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict[str, Any]:
             return self.auth_logout(profile=profile, forget_persisted=forget_persisted)
 
-    @tool_cn_name("凭证登录")
     def auth_use_credential(
         self,
         *,
@@ -86,7 +85,8 @@ class AuthTools(ToolBase):
         persist: bool = False,
     ) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
-        resolved_base_url, resolved_credential = self._resolve_mcporter_auth_inputs(
+        resolved_base_url, resolved_credential = self._resolve_auth_inputs(
+            profile=profile,
             base_url=base_url,
             credential=credential,
         )
@@ -307,10 +307,18 @@ class AuthTools(ToolBase):
             ),
         }
 
-    def _resolve_mcporter_auth_inputs(self, *, base_url: str | None, credential: str | None) -> tuple[str | None, str]:
-        """从参数或 mcporter 配置解析登录所需 base_url 与 credential。"""
+    def _resolve_auth_inputs(
+        self,
+        *,
+        profile: str,
+        base_url: str | None,
+        credential: str | None,
+    ) -> tuple[str | None, str]:
+        """按显式参数、环境变量、mcporter、profile 的顺序解析认证输入。"""
         normalized_base_url = self._normalize_text(base_url)
         normalized_credential = self._normalize_text(credential)
+        if not normalized_credential:
+            normalized_credential = self._normalize_text(os.getenv("QINGFLOW_CREDENTIAL"))
         if normalized_base_url and normalized_credential:
             return normalized_base_url, normalized_credential
 
@@ -318,11 +326,13 @@ class AuthTools(ToolBase):
         if not normalized_base_url:
             normalized_base_url = self._normalize_text(mcporter_context.get("base_url"))
         if not normalized_base_url:
-            normalized_base_url = os.getenv("QINGFLOW_BASE_URL")
+            normalized_base_url = self._normalize_text(os.getenv("QINGFLOW_BASE_URL"))
         if not normalized_credential:
             normalized_credential = self._normalize_text(mcporter_context.get("credential"))
         if not normalized_credential:
-            normalized_credential = os.getenv("QINGFLOW_CREDENTIAL")
+            session_profile = self.sessions.peek_profile(profile)
+            if session_profile is not None:
+                normalized_credential = self._normalize_text(session_profile.credential)
         return normalized_base_url, normalized_credential or ""
 
     def _read_mcporter_qingflow_context(self) -> dict[str, str]:
@@ -356,22 +366,18 @@ class AuthTools(ToolBase):
         profile: str,
         session_profile,
     ) -> bool:
-        backend_session = self.sessions.get_backend_session(profile) if session_profile is not None else None
         base_url = session_profile.base_url if session_profile is not None else None
-        credential = backend_session.credential if backend_session is not None else None
         persist = bool(session_profile.persisted) if session_profile is not None else False
         try:
             self.auth_use_credential(
                 profile=profile,
                 base_url=base_url,
-                credential=credential,
                 persist=persist,
             )
         except (QingflowApiError, RuntimeError):
             return False
         return True
 
-    @tool_cn_name("我的身份")
     def auth_whoami(self, *, profile: str = DEFAULT_PROFILE) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
         def build_response(
@@ -503,7 +509,6 @@ class AuthTools(ToolBase):
             if error.looks_like_invalid_token():
                 raise
 
-    @tool_cn_name("退出登录")
     def auth_logout(self, *, profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
         if not self.sessions.has_profile(profile):

package/src/qingflow_mcp/tools/base.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import inspect
+import os
 from contextvars import ContextVar
 from typing import Any, Callable, TypeVar
 
@@ -20,17 +20,6 @@ T = TypeVar("T")
 _RUN_DEPTH: ContextVar[int] = ContextVar("qingflow_mcp_tool_run_depth", default=0)
 
 
-def tool_cn_name(name: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
-    """为 tools 方法声明中文展示名（用于计费 extraInfo 记录）。"""
-    normalized = str(name).strip()
-
-    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
-        setattr(func, "__tool_cn_name__", normalized)
-        return func
-
-    return decorator
-
-
 class ToolBase:
     def __init__(self, sessions: SessionStore, backend: BackendClient) -> None:
         self.sessions = sessions
@@ -41,6 +30,7 @@ class ToolBase:
         if cloud_context is not None:
             return cloud_context.as_tool_context(profile)
 
+        self._ensure_environment_credential_matches(profile)
         session_profile = self.sessions.get_profile(profile)
         if session_profile is None:
             raise QingflowApiError.auth_required(profile)
@@ -62,19 +52,26 @@ class ToolBase:
         )
         return session_profile, backend_session, context
 
-    def _run(self, profile: str, func: Callable[[SessionProfile, BackendRequestContext], T], *, require_workspace: bool = True) -> T:
+    def _run(
+        self,
+        profile: str,
+        func: Callable[[SessionProfile, BackendRequestContext], T],
+        *,
+        require_workspace: bool = True,
+        tool_name: str,
+    ) -> T:
         depth = _RUN_DEPTH.get()
         depth_token = _RUN_DEPTH.set(depth + 1)
         is_top_level_call = depth == 0
         session_profile: SessionProfile | None = None
         backend_session: BackendSession | None = None
-        tool_name = self._resolve_calling_tool_name()
+        resolved_tool_name = self._normalize_tool_name(tool_name)
         try:
             session_profile, backend_session, context = self._require_context(profile, require_workspace=require_workspace)
             if is_top_level_call:
                 self._charge_tool_call(
                     profile=profile,
-                    tool_name=tool_name,
+                    tool_name=resolved_tool_name,
                     session_profile=session_profile,
                     context=context,
                 )
@@ -106,6 +103,12 @@ class ToolBase:
             _RUN_DEPTH.reset(depth_token)
         raise AssertionError("unreachable")
 
+    def _normalize_tool_name(self, tool_name: str) -> str:
+        normalized = str(tool_name or "").strip()
+        if not normalized:
+            raise_tool_error(QingflowApiError.config_error("tool_name is required for credit usage tracking"))
+        return normalized
+
     def _handle_error(self, profile: str, error: QingflowApiError) -> None:
         if error.looks_like_invalid_token():
             cloud_context = current_cloud_context.get()
@@ -150,50 +153,106 @@ class ToolBase:
         if not credential:
             return False
         try:
-            response = self.backend.public_request_with_meta(
-                "POST",
-                session_profile.base_url,
-                "/mcp/auth/context",
-                json_body={"credential": credential},
-                qf_version=backend_session.qf_version,
-            )
-            payload = self._unwrap_context_payload(response.data)
-            token = self._normalize_text(payload.get("token"))
-            ws_id = self._coerce_positive_int(payload.get("wsId"))
-            uid = self._coerce_positive_int(payload.get("uid")) or session_profile.uid
-            if not token or ws_id is None:
-                return False
-            backend_qf_version = self._normalize_text(payload.get("qfVersion")) or response.qf_response_version
-            qf_version = backend_qf_version if backend_qf_version is not None else backend_session.qf_version
-            qf_version_source = (
-                "backend_response"
-                if backend_qf_version is not None
-                else backend_session.qf_version_source
-            )
-            base_url = self._normalize_text(payload.get("baseUrl")) or session_profile.base_url
-            ws_name = self._normalize_text(payload.get("wsName")) or session_profile.selected_ws_name
-            self.sessions.save_session(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                qf_version_source=qf_version_source,
-                token=token,
-                login_token=None,
+            self._exchange_session_from_credential(
+                profile,
+                session_profile=session_profile,
                 credential=credential,
-                uid=uid,
-                email=self._normalize_text(payload.get("email")) or session_profile.email,
-                nick_name=(
-                    self._normalize_text(payload.get("nickName"))
-                    or self._normalize_text(payload.get("displayName"))
-                    or self._normalize_text(payload.get("name"))
-                    or session_profile.nick_name
-                ),
-                persist=session_profile.persisted,
             )
-            self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=ws_name)
-            return True
         except QingflowApiError:
             return False
+        return True
+
+    def _ensure_environment_credential_matches(self, profile: str) -> None:
+        environment_credential = self._normalize_text(os.getenv("QINGFLOW_CREDENTIAL"))
+        if environment_credential is None:
+            return
+        session_profile = self.sessions.peek_profile(profile)
+        if session_profile is None:
+            return
+        if self._normalize_text(session_profile.credential) == environment_credential:
+            return
+        try:
+            self._exchange_session_from_credential(
+                profile,
+                session_profile=session_profile,
+                credential=environment_credential,
+                preserve_existing_metadata=False,
+            )
+        except QingflowApiError as error:
+            raise QingflowApiError(
+                category="auth",
+                message=(
+                    f"QINGFLOW_CREDENTIAL changed for profile '{profile}', "
+                    "but the session could not be refreshed."
+                ),
+                backend_code=error.backend_code,
+                request_id=error.request_id,
+                http_status=error.http_status,
+                details={
+                    "reason": "environment_credential_changed",
+                },
+            ) from error
+
+    def _exchange_session_from_credential(
+        self,
+        profile: str,
+        *,
+        session_profile: SessionProfile,
+        credential: str,
+        preserve_existing_metadata: bool = True,
+    ) -> None:
+        response = self.backend.public_request_with_meta(
+            "POST",
+            session_profile.base_url,
+            "/mcp/auth/context",
+            json_body={"credential": credential},
+            qf_version=session_profile.qf_version,
+        )
+        payload = self._unwrap_context_payload(response.data)
+        token = self._normalize_text(payload.get("token"))
+        ws_id = self._coerce_positive_int(payload.get("wsId"))
+        response_uid = self._coerce_positive_int(payload.get("uid"))
+        if not token or ws_id is None or (response_uid is None and not preserve_existing_metadata):
+            raise QingflowApiError(
+                category="auth",
+                message="Credential context did not return a valid user session and workspace.",
+                request_id=response.request_id,
+                http_status=response.http_status,
+            )
+        uid = response_uid or session_profile.uid
+        backend_qf_version = self._normalize_text(payload.get("qfVersion")) or response.qf_response_version
+        qf_version = backend_qf_version if backend_qf_version is not None else session_profile.qf_version
+        qf_version_source = (
+            "backend_response"
+            if backend_qf_version is not None
+            else session_profile.qf_version_source
+        )
+        base_url = self._normalize_text(payload.get("baseUrl")) or session_profile.base_url
+        ws_name = self._normalize_text(payload.get("wsName"))
+        email = self._normalize_text(payload.get("email"))
+        nick_name = (
+            self._normalize_text(payload.get("nickName"))
+            or self._normalize_text(payload.get("displayName"))
+            or self._normalize_text(payload.get("name"))
+        )
+        if preserve_existing_metadata:
+            ws_name = ws_name or session_profile.selected_ws_name
+            email = email or session_profile.email
+            nick_name = nick_name or session_profile.nick_name
+        self.sessions.save_session(
+            profile=profile,
+            base_url=base_url,
+            qf_version=qf_version,
+            qf_version_source=qf_version_source,
+            token=token,
+            login_token=None,
+            credential=credential,
+            uid=uid,
+            email=email,
+            nick_name=nick_name,
+            persist=session_profile.persisted,
+        )
+        self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=ws_name)
 
     def _unwrap_context_payload(self, payload: Any) -> dict[str, Any]:
         if not isinstance(payload, dict):
@@ -221,25 +280,6 @@ class ToolBase:
             return None
         return parsed if parsed > 0 else None
 
-    def _resolve_calling_tool_name(self) -> str:
-        frame = inspect.currentframe()
-        if frame is None:
-            return "unknown_tool"
-        caller = frame.f_back.f_back if frame.f_back is not None else None
-        try:
-            if caller is None:
-                return "unknown_tool"
-            name = caller.f_code.co_name
-            if not name:
-                return "unknown_tool"
-            method = getattr(self, name, None)
-            cn_name = getattr(method, "__tool_cn_name__", None)
-            if isinstance(cn_name, str) and cn_name.strip():
-                return cn_name.strip()
-            return name
-        finally:
-            del frame
-
     def _charge_tool_call(
         self,
         *,

package/src/qingflow_mcp/tools/code_block_tools.py

@@ -7,7 +7,6 @@ from mcp.server.fastmcp import FastMCP
 from ..config import DEFAULT_PROFILE, DEFAULT_RECORD_LIST_TYPE
 from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error, message_looks_like_invalid_token, raise_tool_error
 from ..json_types import JSONObject, JSONValue
-from .base import tool_cn_name
 from .record_tools import (
     ATTACHMENT_QUE_TYPES,
     DEPARTMENT_QUE_TYPES,
@@ -156,7 +155,6 @@ class CodeBlockTools(RecordTools):
                 output_profile=output_profile,
             )
 
-    @tool_cn_name("代码块 Schema")
     def record_code_block_schema_get_public(
         self,
         *,
@@ -263,9 +261,8 @@ class CodeBlockTools(RecordTools):
                 )
             return response
 
-        return self._run_record_tool(profile, runner)
+        return self._run_record_tool(profile, runner, tool_name="代码块 Schema")
 
-    @tool_cn_name("运行代码块")
     def record_code_block_run(
         self,
         *,
@@ -549,7 +546,7 @@ class CodeBlockTools(RecordTools):
                 }
             return response
 
-        return self._run_record_tool(profile, runner)
+        return self._run_record_tool(profile, runner, tool_name="运行代码块")
 
     def _resolve_code_block_field_for_run(self, selector: str | int, index: FieldIndex) -> FormField:
         field_id = _coerce_count(selector)