@qingflow-tech/qingflow-app-user-mcp 1.0.0 → 1.0.2

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @qingflow-tech/qingflow-app-user-mcp@1.0.0
+npm install @qingflow-tech/qingflow-app-user-mcp@1.0.2
 ```
 
 Run:
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-app-user-mcp@1.0.0 qingflow-app-user-mcp
+npx -y -p @qingflow-tech/qingflow-app-user-mcp@1.0.2 qingflow-app-user-mcp
 ```
 
 Environment:

package/docs/local-agent-install.md

@@ -152,14 +152,8 @@ qingflow-app-builder-mcp
         "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
         "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
         "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
-        "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL": "https://ultron.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY": "wingsTokenKey",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE": "replace-prod-balance-token",
         "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY": "serviceToken",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE": "729ed3cc-8eea-11ec-b585-52540009137b",
-        "QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY": "wsId",
-        "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT": "1"
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
       }
     }
   }
@@ -178,14 +172,8 @@ qingflow-app-builder-mcp
         "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
         "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
         "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
-        "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL": "https://ultron.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY": "wingsTokenKey",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE": "replace-prod-balance-token",
         "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY": "serviceToken",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE": "729ed3cc-8eea-11ec-b585-52540009137b",
-        "QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY": "wsId",
-        "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT": "1"
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
       }
     }
   }
@@ -204,14 +192,8 @@ qingflow-app-builder-mcp
         "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
         "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
         "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
-        "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL": "https://ultron.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY": "wingsTokenKey",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE": "replace-prod-balance-token",
         "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY": "serviceToken",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE": "729ed3cc-8eea-11ec-b585-52540009137b",
-        "QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY": "wsId",
-        "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT": "1"
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
       }
     }
   }
@@ -234,14 +216,8 @@ qingflow-app-builder-mcp
       "env": {
         "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
         "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
-        "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL": "https://ultron.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY": "wingsTokenKey",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE": "replace-prod-balance-token",
         "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY": "serviceToken",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE": "729ed3cc-8eea-11ec-b585-52540009137b",
-        "QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY": "wsId",
-        "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT": "1"
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
       }
     },
     "qingflow-builder": {
@@ -253,14 +229,8 @@ qingflow-app-builder-mcp
       "env": {
         "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
         "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
-        "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL": "https://ultron.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY": "wingsTokenKey",
-        "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE": "replace-prod-balance-token",
         "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY": "serviceToken",
-        "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE": "729ed3cc-8eea-11ec-b585-52540009137b",
-        "QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY": "wsId",
-        "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT": "1"
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
       }
     }
   }
@@ -271,7 +241,7 @@ qingflow-app-builder-mcp
 - 源码目录 `npm install` 不会把命令加到全局 PATH；这种模式请用 `node ./npm/bin/qingflow.mjs`、`node ./npm/bin/qingflow-app-user-mcp.mjs` 或 `node ./npm/bin/qingflow-app-builder-mcp.mjs`
 - `npx` 方式适合临时安装或容器化本地 agent
 - 全局安装方式更适合长期固定使用的本机开发环境
-- 计费接口鉴权参数需要分系统配置：`QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY/VALUE`（wings）与 `QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY/VALUE`（apaas）互不复用
+- 计费接口使用当前登录会话的 `token` 与 `wsId` 请求头，可通过 `QINGFLOW_MCP_CREDIT_APAAS_BASE_URL/PATH` 覆盖调用记录接口地址
 
 ## 排障
 
@@ -328,5 +298,6 @@ qingflow auth use-credential \
 
 说明：
 
-- `persist=true` 时，本地会优先把解析后的 `token` 和原始 `credential` 写入系统 keychain
+- 本地会把解析后的 `token` 和原始 `credential` 写入 profile 文件，用于后续 CLI 命令恢复会话
+- `persist=true` 时，本地还会优先把解析后的 `token` 和原始 `credential` 同步写入系统 keychain
 - 当前工作区以 `/mcp/auth/context` 返回的 `wsId` 为准，不再通过本地 MCP 显式切换

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-app-user-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/src/qingflow_mcp/cli/commands/auth.py

@@ -25,8 +25,13 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     logout.add_argument("--forget-persisted", action="store_true")
     logout.set_defaults(handler=_handle_logout, format_hint="")
 
+
 def _handle_use_credential(args: argparse.Namespace, context: CliContext) -> dict:
-    credential = read_secret_arg(args.credential, stdin_enabled=bool(args.credential_stdin), label="credential")
+    credential = (
+        read_secret_arg(args.credential, stdin_enabled=bool(args.credential_stdin), label="credential")
+        if args.credential or bool(args.credential_stdin)
+        else ""
+    )
     return context.auth.auth_use_credential(
         profile=args.profile,
         base_url=args.base_url,

package/src/qingflow_mcp/config.py

@@ -21,13 +21,8 @@ DEFAULT_REPOSITORY_PROD_BRANCH = "prod"
 DEFAULT_REPOSITORY_AUTHOR_NAME = "qingflow-mcp"
 DEFAULT_REPOSITORY_AUTHOR_EMAIL = "qingflow-mcp@local.invalid"
 DEFAULT_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY = "tokenKey"
-DEFAULT_CREDIT_BALANCE_PATH = "/ultron/internal/credit/balance"
-DEFAULT_CREDIT_USAGE_RECORD_PATH = "/share/workspace/credit/usage/record"
-DEFAULT_CREDIT_WINGS_TOKEN_HEADER_KEY = "wingsTokenKey"
-DEFAULT_CREDIT_APAAS_TOKEN_HEADER_KEY = "serviceToken"
-DEFAULT_CREDIT_WS_ID_HEADER_KEY = "wsId"
-DEFAULT_CREDIT_USAGE_AMOUNT = "1"
-DEFAULT_CREDIT_APAAS_TOKEN_VALUE = "729ed3cc-8eea-11ec-b585-52540009137b"
+DEFAULT_CREDIT_USAGE_RECORD_PATH = "/user/credit/usage"
+DEFAULT_MCPORTER_CONFIG_PATH = "/root/.openclaw/workspace/config/mcporter.json"
 
 
 def get_mcp_home() -> Path:
@@ -39,6 +34,13 @@ def get_profiles_path() -> Path:
     return get_mcp_home() / "profiles.json"
 
 
+def get_mcporter_config_path() -> Path:
+    custom_path = os.getenv("QINGFLOW_MCP_MCPORTER_CONFIG_PATH") or os.getenv(
+        "QINGFLOW_MCP_AUTH_CONFIG_PATH"
+    )
+    return Path(custom_path).expanduser() if custom_path else Path(DEFAULT_MCPORTER_CONFIG_PATH)
+
+
 def get_repository_metadata_dir() -> Path:
     return get_mcp_home() / "repository-metadata"
 
@@ -225,80 +227,6 @@ def get_credit_meter_enabled() -> bool:
     return normalized in {"1", "true", "yes", "on"}
 
 
-def get_credit_shared_token_key() -> str:
-    value = get_config_value(
-        "credit_meter.shared_token_key",
-        env_var="QINGFLOW_MCP_CREDIT_TOKEN_KEY",
-        default=DEFAULT_CREDIT_APAAS_TOKEN_HEADER_KEY,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_APAAS_TOKEN_HEADER_KEY
-
-
-def get_credit_shared_token_value() -> str | None:
-    value = get_config_value(
-        "credit_meter.shared_token_value",
-        env_var="QINGFLOW_MCP_CREDIT_TOKEN_VALUE",
-        default=None,
-    )
-    normalized = str(value or "").strip()
-    return normalized or None
-
-
-def get_credit_shared_ws_id_header_key() -> str:
-    value = get_config_value(
-        "credit_meter.shared_ws_id_header_key",
-        env_var="QINGFLOW_MCP_CREDIT_WS_ID_HEADER_KEY",
-        default=DEFAULT_CREDIT_WS_ID_HEADER_KEY,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_WS_ID_HEADER_KEY
-
-
-def get_credit_balance_base_url() -> str | None:
-    value = get_config_value(
-        "credit_meter.wings.base_url",
-        env_var="QINGFLOW_MCP_CREDIT_WINGS_BASE_URL",
-        default=None,
-    )
-    normalized = normalize_base_url(value)
-    return normalized or None
-
-
-def get_credit_balance_path() -> str:
-    value = get_config_value(
-        "credit_meter.wings.path",
-        env_var="QINGFLOW_MCP_CREDIT_WINGS_PATH",
-        default=DEFAULT_CREDIT_BALANCE_PATH,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_BALANCE_PATH
-
-
-def get_credit_balance_token_key() -> str:
-    value = get_config_value(
-        "credit_meter.wings.token_key",
-        env_var="QINGFLOW_MCP_CREDIT_WINGS_TOKEN_KEY",
-        default=DEFAULT_CREDIT_WINGS_TOKEN_HEADER_KEY,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_WINGS_TOKEN_HEADER_KEY
-
-
-def get_credit_balance_token_value() -> str | None:
-    value = get_config_value(
-        "credit_meter.wings.token_value",
-        env_var="QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE",
-        default=None,
-    )
-    normalized = str(value or "").strip()
-    return normalized or None
-
-
-def get_credit_balance_ws_id_header_key() -> str:
-    return get_credit_shared_ws_id_header_key()
-
-
 def get_credit_usage_base_url() -> str | None:
     value = get_config_value(
         "credit_meter.apaas.base_url",
@@ -319,40 +247,6 @@ def get_credit_usage_path() -> str:
     return normalized or DEFAULT_CREDIT_USAGE_RECORD_PATH
 
 
-def get_credit_usage_token_key() -> str:
-    value = get_config_value(
-        "credit_meter.apaas.token_key",
-        env_var="QINGFLOW_MCP_CREDIT_APAAS_TOKEN_KEY",
-        default=DEFAULT_CREDIT_APAAS_TOKEN_HEADER_KEY,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_APAAS_TOKEN_HEADER_KEY
-
-
-def get_credit_usage_token_value() -> str | None:
-    value = get_config_value(
-        "credit_meter.apaas.token_value",
-        env_var="QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE",
-        default=DEFAULT_CREDIT_APAAS_TOKEN_VALUE,
-    )
-    normalized = str(value or "").strip()
-    return normalized or None
-
-
-def get_credit_usage_ws_id_header_key() -> str:
-    return get_credit_shared_ws_id_header_key()
-
-
-def get_credit_usage_amount() -> str:
-    value = get_config_value(
-        "credit_meter.apaas.amount",
-        env_var="QINGFLOW_MCP_CREDIT_APAAS_AMOUNT",
-        default=DEFAULT_CREDIT_USAGE_AMOUNT,
-    )
-    normalized = str(value or "").strip()
-    return normalized or DEFAULT_CREDIT_USAGE_AMOUNT
-
-
 def get_repository_default_group() -> str | None:
     value = get_config_value(
         "repository.default_group",

package/src/qingflow_mcp/session_store.py

@@ -28,6 +28,9 @@ class SessionProfile:
     base_url: str
     qf_version: str | None
     qf_version_source: str | None
+    token: str | None
+    login_token: str | None
+    credential: str | None
     uid: int
     email: str | None
     nick_name: str | None
@@ -44,6 +47,9 @@ class SessionProfile:
             base_url=value["base_url"],
             qf_version=value.get("qf_version"),
             qf_version_source=value.get("qf_version_source"),
+            token=value.get("token"),
+            login_token=value.get("login_token"),
+            credential=value.get("credential"),
             uid=value["uid"],
             email=value.get("email"),
             nick_name=value.get("nick_name"),
@@ -112,6 +118,9 @@ class SessionStore:
             base_url=normalize_base_url(base_url) or base_url,
             qf_version=(str(qf_version).strip() or None) if qf_version is not None else None,
             qf_version_source=(str(qf_version_source).strip() or None) if qf_version_source is not None else None,
+            token=str(token).strip() or None,
+            login_token=(str(login_token).strip() or None) if login_token is not None else None,
+            credential=(str(credential).strip() or None) if credential is not None else None,
             uid=uid,
             email=email,
             nick_name=nick_name,
@@ -122,9 +131,9 @@ class SessionStore:
             updated_at=now,
         )
         self._memory_sessions[profile] = BackendSession(
-            token=token,
-            login_token=login_token,
-            credential=(str(credential).strip() or None) if credential is not None else None,
+            token=session_profile.token or token,
+            login_token=session_profile.login_token,
+            credential=session_profile.credential,
             profile=profile,
             base_url=session_profile.base_url,
             qf_version=session_profile.qf_version,
@@ -152,15 +161,19 @@ class SessionStore:
                 memory_session.qf_version = session_profile.qf_version
                 memory_session.qf_version_source = session_profile.qf_version_source
             return memory_session
-        if not session_profile or not session_profile.persisted:
+        if not session_profile:
             return None
-        token = self._get_secret(self._token_key(profile))
+        token = self._get_secret(self._token_key(profile)) if session_profile.persisted else None
+        if not token:
+            token = session_profile.token
         if not token:
             return None
+        login_token = self._get_secret(self._login_token_key(profile)) if session_profile.persisted else None
+        credential = self._get_secret(self._credential_key(profile)) if session_profile.persisted else None
         backend_session = BackendSession(
             token=token,
-            login_token=self._get_secret(self._login_token_key(profile)),
-            credential=self._get_secret(self._credential_key(profile)),
+            login_token=login_token or session_profile.login_token,
+            credential=credential or session_profile.credential,
             profile=profile,
             base_url=session_profile.base_url,
             qf_version=session_profile.qf_version,

package/src/qingflow_mcp/tools/auth_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 
 from mcp.server.fastmcp import FastMCP
@@ -9,6 +10,7 @@ from ..config import (
     DEFAULT_PROFILE,
     get_default_base_url,
     get_default_qf_version,
+    get_mcporter_config_path,
     normalize_base_url,
 )
 from ..errors import QingflowApiError, raise_tool_error
@@ -77,15 +79,24 @@ class AuthTools(ToolBase):
         profile: str = DEFAULT_PROFILE,
         base_url: str | None = None,
         qf_version: str | None = None,
-        credential: str,
+        credential: str | None = None,
         persist: bool = False,
     ) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
-        normalized_base_url = self._normalize_base_url(base_url)
+        resolved_base_url, resolved_credential = self._resolve_mcporter_auth_inputs(
+            base_url=base_url,
+            credential=credential,
+        )
+        normalized_base_url = self._normalize_base_url(resolved_base_url)
         normalized_qf_version, qf_version_source = self._resolve_qf_version_input(qf_version)
-        normalized_credential = str(credential).strip()
+        normalized_credential = str(resolved_credential).strip()
         if not normalized_credential:
-            raise_tool_error(QingflowApiError.config_error("credential is required"))
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    "credential is required or configure /root/.openclaw/workspace/config/mcporter.json "
+                    "with mcpServers.qingflow.headers.x-qingflow-client-id"
+                )
+            )
 
         context_payload, detected_qf_version = self._fetch_auth_context(
             normalized_base_url,
@@ -110,7 +121,6 @@ class AuthTools(ToolBase):
         uid = self._coerce_int(context_payload.get("uid"))
         if uid is None:
             raise_tool_error(QingflowApiError(category="auth", message="Credential context did not return valid user info"))
-
         session_profile = self.sessions.save_session(
             profile=profile,
             base_url=resolved_base_url,
@@ -154,6 +164,46 @@ class AuthTools(ToolBase):
             ),
         }
 
+    def _resolve_mcporter_auth_inputs(self, *, base_url: str | None, credential: str | None) -> tuple[str | None, str]:
+        """从参数或 mcporter 配置解析登录所需 base_url 与 credential。"""
+        normalized_base_url = self._normalize_text(base_url)
+        normalized_credential = self._normalize_text(credential)
+        if normalized_base_url and normalized_credential:
+            return normalized_base_url, normalized_credential
+
+        mcporter_context = self._read_mcporter_qingflow_context()
+        if not normalized_base_url:
+            normalized_base_url = self._normalize_text(mcporter_context.get("base_url"))
+        if not normalized_credential:
+            normalized_credential = self._normalize_text(mcporter_context.get("credential"))
+        return normalized_base_url, normalized_credential or ""
+
+    def _read_mcporter_qingflow_context(self) -> dict[str, str]:
+        """读取 OpenClaw mcporter 中的 Qingflow MCP 上下文。"""
+        path = get_mcporter_config_path()
+        if not path.exists():
+            return {}
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise_tool_error(QingflowApiError.config_error(f"failed to read mcporter config '{path}': {exc}"))
+
+        if not isinstance(payload, dict):
+            raise_tool_error(QingflowApiError.config_error(f"mcporter config '{path}' must be a JSON object"))
+        mcp_servers = payload.get("mcpServers")
+        qingflow = mcp_servers.get("qingflow") if isinstance(mcp_servers, dict) else None
+        if not isinstance(qingflow, dict):
+            return {}
+        headers = qingflow.get("headers")
+        credential = None
+        if isinstance(headers, dict):
+            credential = headers.get("x-qingflow-client-id")
+        return {
+            "base_url": str(qingflow.get("url") or "").strip(),
+            "credential": str(credential or "").strip(),
+        }
+
     @tool_cn_name("我的身份")
     def auth_whoami(self, *, profile: str = DEFAULT_PROFILE) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""

package/src/qingflow_mcp/tools/base.py

@@ -2,23 +2,13 @@ from __future__ import annotations
 
 import inspect
 from contextvars import ContextVar
-from decimal import Decimal, InvalidOperation
 from typing import Any, Callable, TypeVar
 
-from ..backend_client import BackendRequestContext, BackendClient, BackendResponse
+from ..backend_client import BackendRequestContext, BackendClient
 from ..config import (
-    get_credit_balance_base_url,
-    get_credit_balance_path,
-    get_credit_balance_token_key,
-    get_credit_balance_token_value,
-    get_credit_balance_ws_id_header_key,
     get_credit_meter_enabled,
-    get_credit_usage_amount,
     get_credit_usage_base_url,
     get_credit_usage_path,
-    get_credit_usage_token_key,
-    get_credit_usage_token_value,
-    get_credit_usage_ws_id_header_key,
 )
 from ..errors import QingflowApiError, raise_tool_error
 from ..json_types import JSONObject
@@ -224,143 +214,42 @@ class ToolBase:
     ) -> None:
         if not get_credit_meter_enabled():
             return
-        if not self._credit_meter_is_ready():
-            return
         if context.ws_id is None:
             raise_tool_error(QingflowApiError(category="payment", message="credit meter requires wsId in current session context"))
 
-        usage_amount = self._read_usage_amount()
-        available_balance = self._fetch_credit_balance(context.ws_id)
-        if available_balance < usage_amount:
-            raise_tool_error(
-                QingflowApiError(
-                    category="payment",
-                    message=f"insufficient credit balance: available={available_balance}, required={usage_amount}",
-                )
-            )
         self._record_credit_usage(
             tool_name=tool_name,
-            ws_id=context.ws_id,
-            uid=session_profile.uid,
-        )
-
-    def _credit_meter_is_ready(self) -> bool:
-        return bool(
-            get_credit_balance_base_url()
-            and get_credit_balance_token_value()
-            and get_credit_usage_base_url()
-            and get_credit_usage_token_value()
-        )
-
-    def _read_usage_amount(self) -> Decimal:
-        raw_amount = get_credit_usage_amount()
-        try:
-            amount = Decimal(str(raw_amount).strip())
-        except (InvalidOperation, ValueError):
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT must be a positive number"
-                )
-            )
-        if amount <= 0:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_APAAS_AMOUNT must be a positive number"
-                )
-            )
-        return amount
-
-    def _fetch_credit_balance(self, ws_id: int) -> Decimal:
-        balance_base_url = get_credit_balance_base_url()
-        balance_token_key = get_credit_balance_token_key()
-        balance_token_value = get_credit_balance_token_value()
-        ws_id_header_key = get_credit_balance_ws_id_header_key()
-        if not balance_base_url:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_WINGS_BASE_URL is required when credit meter is enabled"
-                )
-            )
-        if not balance_token_value:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_WINGS_TOKEN_VALUE is required when credit meter is enabled"
-                )
-            )
-        response = self.backend.public_request_with_headers(
-            "GET",
-            balance_base_url,
-            get_credit_balance_path(),
-            headers={
-                balance_token_key: balance_token_value,
-                ws_id_header_key: str(ws_id),
-            },
+            context=context,
         )
-        payload: Any = response.data if isinstance(response, BackendResponse) else response
-        if isinstance(payload, dict):
-            daily = self._coerce_decimal(payload.get("dailyBalance"))
-            monthly = self._coerce_decimal(payload.get("monthlyBalance"))
-            permanent = self._coerce_decimal(payload.get("balance"))
-            if daily is not None or monthly is not None or permanent is not None:
-                return (daily or Decimal("0")) + (monthly or Decimal("0")) + (permanent or Decimal("0"))
-        raise_tool_error(
-            QingflowApiError(
-                category="payment",
-                message="credit balance response is invalid: expected dailyBalance/monthlyBalance/balance",
-            )
-        )
-        raise AssertionError("unreachable")
 
     def _record_credit_usage(
         self,
         *,
         tool_name: str,
-        ws_id: int,
-        uid: int,
+        context: BackendRequestContext,
     ) -> None:
-        usage_base_url = get_credit_usage_base_url()
-        usage_token_key = get_credit_usage_token_key()
-        usage_token_value = get_credit_usage_token_value()
-        ws_id_header_key = get_credit_usage_ws_id_header_key()
-        if not usage_base_url:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL is required when credit meter is enabled"
-                )
-            )
-        if not usage_token_value:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "QINGFLOW_MCP_CREDIT_APAAS_TOKEN_VALUE is required when credit meter is enabled"
-                )
-            )
-        self.backend.public_request_with_headers(
+        usage_context = BackendRequestContext(
+            base_url=get_credit_usage_base_url() or context.base_url,
+            token=context.token,
+            ws_id=context.ws_id,
+            qf_request_id=context.qf_request_id,
+            qf_version=context.qf_version,
+            qf_version_source=context.qf_version_source,
+        )
+        self.backend.request(
             "POST",
-            usage_base_url,
+            usage_context,
             get_credit_usage_path(),
-            headers={
-                usage_token_key: usage_token_value,
-                ws_id_header_key: str(ws_id),
-            },
             json_body={
-                "wsId": ws_id,
-                "uid": uid,
-                "creditUsage": "1",
-                "businessType": "WORKSPACE",
+                "skuType": "MCP",
+                "skuName": "MCP",
+                "modelName": "MCP",
                 "scene": "MCP",
-                "aiBiz": "mcp",
+                "aiBiz": "MCP",
                 "extraInfo": tool_name,
             },
         )
 
-    def _coerce_decimal(self, value: Any) -> Decimal | None:
-        if value is None or isinstance(value, bool):
-            return None
-        try:
-            return Decimal(str(value))
-        except (InvalidOperation, ValueError):
-            return None
-
     def _require_dict(self, payload: JSONObject | None, field_name: str = "payload") -> JSONObject:
         if not isinstance(payload, dict) or not payload:
             raise_tool_error(QingflowApiError.config_error(f"{field_name} must be a non-empty object"))

package/src/qingflow_mcp/tools/task_tools.py

@@ -365,7 +365,6 @@ class TaskTools(ToolBase):
         """执行任务相关逻辑。"""
         self._validate_type(type)
         self._validate_process_status(process_status)
-
         def runner(session_profile, context):
             payload: dict[str, Any] = {
                 "type": type,