@qingflow-tech/qingflow-cli 1.1.40 → 1.1.42

package/README.md

@@ -7,7 +7,7 @@ Qingflow CLI 是轻流面向开发者和 AI Agent 的命令行工具。它把轻
 ## 安装
 
 ```bash
-npm install @qingflow-tech/qingflow-cli@1.1.40
+npm install @qingflow-tech/qingflow-cli@1.1.42
 ```
 
 推荐从官网复制这一条一键安装 Qingflow CLI：
@@ -21,7 +21,7 @@ npx qingflow-cli@latest install
 ## 运行
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.40 qingflow
+npx -y -p @qingflow-tech/qingflow-cli@1.1.42 qingflow
 ```
 
 全局安装后可以直接运行：
@@ -55,7 +55,7 @@ qingflow-skills install --agent codex --scope user
 如果你通过一次性 `npx -p` 执行 skills 安装，建议加 `--copy`，避免 symlink 指向 npm 临时执行缓存：
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.40 qingflow-skills install --agent codex --scope user --copy
+npx -y -p @qingflow-tech/qingflow-cli@1.1.42 qingflow-skills install --agent codex --scope user --copy
 ```
 
 `qingflow-skills install` 默认使用 symlink，且遇到同名 skill 不会覆盖；只有显式传入 `--force` 才会替换。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-cli",
-  "version": "1.1.40",
+  "version": "1.1.42",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "1.1.40"
+version = "1.1.42"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/skills/qingflow-cli/reference/QINGFLOW_CLI_TASK_CONTEXT_WORKFLOW.md

@@ -114,7 +114,7 @@ qingflow --json task action \
 - **定位只认 `task_id`**：来自 `task list` 的 `data.items[].task_id`；`app_key`、`record_id`、`workflow_node_id` 不是动作执行入参。
 - `**approve` / `reject`**：执行上下文以当前待办详情或用户/前端已给出的显式 `formId` 为准；只有缺少 `formId` 时才兜底读取应用 baseInfo。不要把应用 baseInfo 的 `40002` 当作待办动作最终无权结论，最终是否可执行以后端审批动作接口为准。
 - `**save_only`**：必须 提供非空 `**--fields-file`**（或 payload 与 fields 不能同时塞 `answers` 与 fields，具体以报错为准）。以当前待办节点的 `data.editable_fields` / `editableQueIds` 为准；若 `editableQueIds` 被当前权限链路挡住，但任务详情里的 `queAuthSetting` 已暴露可编辑字段，CLI 会按任务详情继续允许 save-only，并由最终保存接口裁决。申请表单 schema 或辅助 `editableQueIds` 的 `40002` 不是待办字段保存的最终无权结论。
-- `**transfer**`：`**payload` 内需要** `target_member_id`（或别名 `uid` / `targetMemberId`）；不能转给当前登录人。
+- `**transfer**`：`**payload` 内需要** `target_member_id`（或别名 `uid` / `targetMemberId`）；不能转给当前登录人。未提供 `payload.answers` 且没有通过 `--fields-file` 修改字段时，CLI 会先读取当前待办详情，并将已有 `answers` 原样带入转交请求；显式 `payload.answers` 或 `--fields-file` 合并结果优先。
 - **意见必填**：若详情里 `**action_constraints.feedback_required_for`** 包含当前动作，需在 `**payload.audit_feedback`**（实现从 payload 抽取审计意见，具体键名以 `--help` / 服务端为准）中提供，否则会 config 错误。
 - `**urge`**：**不支持** 与 `fields` 同时提交。
 - **禁止臆测动作**：只允许 `**data.available_actions`** 中出现的动作；`approve` 不在列表则不可硬放行。

package/skills/qingflow-cli/reference/task/QINGFLOW_CLI_TASK_CONTEXT_WORKFLOW.md

@@ -116,7 +116,7 @@ qingflow --json task action \
 - **定位只认 `task_id`**：来自 `task list` 的 `data.items[].task_id`；`app_key`、`record_id`、`workflow_node_id` 不是动作执行入参。
 - `**approve` / `reject`**：执行上下文以当前待办详情或用户/前端已给出的显式 `formId` 为准；只有缺少 `formId` 时才兜底读取应用 baseInfo。不要把应用 baseInfo 的 `40002` 当作待办动作最终无权结论，最终是否可执行以后端审批动作接口为准。
 - `**save_only`**：必须 提供非空 `**--fields-file`**（或 payload 与 fields 不能同时塞 `answers` 与 fields，具体以报错为准）。以当前待办节点的 `data.editable_fields` / `editableQueIds` 为准；若 `editableQueIds` 被当前权限链路挡住，但任务详情里的 `queAuthSetting` 已暴露可编辑字段，CLI 会按任务详情继续允许 save-only，并由最终保存接口裁决。申请表单 schema 或辅助 `editableQueIds` 的 `40002` 不是待办字段保存的最终无权结论。
-- `**transfer**`：`**payload` 内需要** `target_member_id`（或别名 `uid` / `targetMemberId`）；不能转给当前登录人。
+- `**transfer**`：`**payload` 内需要** `target_member_id`（或别名 `uid` / `targetMemberId`）；不能转给当前登录人。未提供 `payload.answers` 且没有通过 `--fields-file` 修改字段时，CLI 会先读取当前待办详情，并将已有 `answers` 原样带入转交请求；显式 `payload.answers` 或 `--fields-file` 合并结果优先。
 - **意见必填**：若详情里 `**action_constraints.feedback_required_for`** 包含当前动作，需在 `**payload.audit_feedback`**（实现从 payload 抽取审计意见，具体键名以 `--help` / 服务端为准）中提供，否则会 config 错误。
 - `**urge`**：**不支持** 与 `fields` 同时提交。
 - **禁止臆测动作**：只允许 `**data.available_actions`** 中出现的动作；`approve` 不在列表则不可硬放行。

package/src/qingflow_mcp/cloud_auth.py

@@ -25,6 +25,7 @@ from .json_types import JSONObject
 AUTH_CONTEXT_KEY_PREFIX = "mcp:auth:context"
 AUTH_CONTEXT_LOCK_KEY_PREFIX = "mcp:auth:context:lock"
 AUTH_CONTEXT_NEGATIVE_KEY_PREFIX = "mcp:auth:context:negative"
+ACCESS_PLATFORM_KEY_PREFIX = "oauth2:access-platform:"
 
 
 @dataclass(slots=True)
@@ -103,6 +104,16 @@ class CloudAuthBroker:
     def invalidate(self, credential_hash: str) -> None:
         self.cache.delete(self._auth_key(credential_hash))
 
+    def resolve_call_platform(self, access_token: str) -> str:
+        normalized_token = self._normalize_text(access_token)
+        if normalized_token is None:
+            return ""
+        try:
+            value = self.cache.get_text(f"{ACCESS_PLATFORM_KEY_PREFIX}{normalized_token}")
+        except QingflowApiError:
+            return ""
+        return self._normalize_text(value) or ""
+
     @staticmethod
     def credential_hash(credential: str) -> str:
         return sha256(credential.encode("utf-8")).hexdigest()

package/src/qingflow_mcp/cloud_context.py

@@ -68,3 +68,8 @@ current_cloud_context: ContextVar[CloudMcpContext | None] = ContextVar(
     "qingflow_mcp_current_cloud_context",
     default=None,
 )
+
+current_call_platform: ContextVar[str] = ContextVar(
+    "qingflow_mcp_current_call_platform",
+    default="",
+)

package/src/qingflow_mcp/cloud_oauth_proxy.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import httpx
+
+from .backend_client import BackendClient, BackendRequestContext
+from .cloud_context import CloudMcpContext
+from .config import (
+    get_cloud_oauth_resource_url,
+    get_cloud_oauth_service_base_url,
+    get_default_base_url,
+    get_default_qf_version,
+    get_timeout_seconds,
+    normalize_base_url,
+)
+from .errors import QingflowApiError, is_auth_like_error
+from .json_types import JSONObject
+
+
+PROTECTED_RESOURCE_METADATA_PATH = "/.well-known/oauth-protected-resource"
+AUTHORIZATION_SERVER_METADATA_PATH = "/.well-known/oauth-authorization-server"
+HOP_BY_HOP_RESPONSE_HEADERS = {
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "date",
+    "server",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class CloudOAuthProxyConfig:
+    service_base_url: str
+    resource_url: str
+
+    @classmethod
+    def from_config(cls) -> "CloudOAuthProxyConfig | None":
+        resource_url = get_cloud_oauth_resource_url()
+        if resource_url is None:
+            return None
+        service_base_url = get_cloud_oauth_service_base_url()
+        if service_base_url is None:
+            raise QingflowApiError.config_error(
+                "cloud.oauth.service_base_url or default_base_url is required when OAuth is enabled"
+            )
+        return cls(
+            service_base_url=service_base_url,
+            resource_url=_validate_resource_url(resource_url),
+        )
+
+    @property
+    def resource_metadata_url(self) -> str:
+        parsed = urlsplit(self.resource_url)
+        return urlunsplit(
+            (parsed.scheme, parsed.netloc, PROTECTED_RESOURCE_METADATA_PATH, "", "")
+        )
+
+    def backend_metadata_path(self, request_path: str) -> str | None:
+        if request_path == PROTECTED_RESOURCE_METADATA_PATH or request_path.startswith(
+            f"{PROTECTED_RESOURCE_METADATA_PATH}/"
+        ):
+            return PROTECTED_RESOURCE_METADATA_PATH
+        if request_path == AUTHORIZATION_SERVER_METADATA_PATH or request_path.startswith(
+            f"{AUTHORIZATION_SERVER_METADATA_PATH}/"
+        ):
+            return AUTHORIZATION_SERVER_METADATA_PATH
+        return None
+
+
+@dataclass(frozen=True, slots=True)
+class OAuthProxyResponse:
+    status_code: int
+    headers: tuple[tuple[bytes, bytes], ...]
+    body: bytes
+
+
+class OAuthServiceProxy:
+    def __init__(
+        self,
+        config: CloudOAuthProxyConfig,
+        *,
+        client: httpx.Client | None = None,
+    ) -> None:
+        self.config = config
+        self._owns_client = client is None
+        self._client = client or httpx.Client(
+            timeout=get_timeout_seconds(),
+            follow_redirects=False,
+            trust_env=False,
+        )
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def request_metadata(
+        self,
+        method: str,
+        backend_path: str,
+        query_string: bytes = b"",
+    ) -> OAuthProxyResponse:
+        url = f"{self.config.service_base_url}/{backend_path.lstrip('/')}"
+        if query_string:
+            url = f"{url}?{query_string.decode('latin1')}"
+        try:
+            response = self._client.request(
+                method.upper(),
+                url,
+                headers={"Accept": "application/json"},
+            )
+        except httpx.RequestError as error:
+            raise QingflowApiError(
+                category="network",
+                message=f"OAuth service request failed: {error}",
+            ) from error
+
+        headers = tuple(
+            (name.encode("latin1"), value.encode("latin1"))
+            for name, value in response.headers.multi_items()
+            if name.lower() not in HOP_BY_HOP_RESPONSE_HEADERS
+            and name.lower() != "content-length"
+        )
+        return OAuthProxyResponse(
+            status_code=response.status_code,
+            headers=headers,
+            body=response.content,
+        )
+
+
+@dataclass(slots=True)
+class OAuthAccessTokenResolver:
+    backend: BackendClient
+    base_url: str
+    qf_version: str | None = None
+
+    @classmethod
+    def from_config(cls, backend: BackendClient) -> "OAuthAccessTokenResolver":
+        base_url = get_default_base_url()
+        if base_url is None:
+            raise QingflowApiError.config_error(
+                "default_base_url is required for OAuth access token requests"
+            )
+        return cls(
+            backend=backend,
+            base_url=base_url,
+            qf_version=get_default_qf_version(),
+        )
+
+    def resolve(self, access_token: str) -> CloudMcpContext:
+        normalized_token = str(access_token or "").strip()
+        if not normalized_token:
+            raise QingflowApiError(category="auth", message="OAuth access token is required")
+
+        user_info, workspace, response_qf_version = self._load_backend_context(
+            normalized_token
+        )
+        uid = self._coerce_positive_int(user_info.get("uid"))
+        ws_id = self._coerce_positive_int(workspace.get("wsId"))
+        if uid is None or ws_id is None:
+            raise QingflowApiError(
+                category="auth",
+                message="OAuth access token did not resolve a valid user and workspace",
+            )
+
+        workspace_qf_version, workspace_qf_version_source = (
+            self._resolve_workspace_qf_version(workspace)
+        )
+        qf_version = workspace_qf_version or response_qf_version or self.qf_version
+        qf_version_source = (
+            workspace_qf_version_source
+            if workspace_qf_version
+            else "backend_response"
+            if response_qf_version
+            else "default_config"
+            if self.qf_version
+            else None
+        )
+        return CloudMcpContext(
+            credential_hash="",
+            credential="",
+            token=normalized_token,
+            uid=uid,
+            ws_id=ws_id,
+            base_url=self.base_url,
+            qf_version=qf_version,
+            qf_version_source=qf_version_source,
+            email=self._normalize_text(user_info.get("email")),
+            nick_name=self._normalize_text(
+                user_info.get("nickName")
+                or user_info.get("displayName")
+                or user_info.get("name")
+            ),
+            ws_name=self._normalize_text(
+                workspace.get("workspaceName")
+                or workspace.get("wsName")
+                or workspace.get("remark")
+            ),
+        )
+
+    def _load_backend_context(
+        self, access_token: str
+    ) -> tuple[JSONObject, JSONObject, str | None]:
+        first_workspace: JSONObject | None = None
+        response_qf_version: str | None = None
+        try:
+            user_response = self.backend.request_with_meta(
+                "GET",
+                self._request_context(access_token, None),
+                "/user",
+            )
+        except QingflowApiError as original_error:
+            first_workspace, response_qf_version = self._fetch_first_workspace(
+                access_token
+            )
+            if first_workspace is None:
+                raise original_error
+            first_ws_id = self._coerce_positive_int(first_workspace.get("wsId"))
+            if first_ws_id is None:
+                raise original_error
+            user_response = self.backend.request_with_meta(
+                "GET",
+                self._request_context(
+                    access_token, first_ws_id, response_qf_version
+                ),
+                "/user",
+            )
+
+        user_info = self._as_object(user_response.data)
+        if user_info is None:
+            raise QingflowApiError(
+                category="auth", message="OAuth access token did not resolve user info"
+            )
+        response_qf_version = user_response.qf_response_version or response_qf_version
+
+        workspace = self._as_object(user_info.get("lastWsInfo")) or first_workspace
+        if workspace is None:
+            workspace, workspace_response_version = self._fetch_first_workspace(
+                access_token
+            )
+            response_qf_version = workspace_response_version or response_qf_version
+        if workspace is None:
+            raise QingflowApiError(
+                category="auth",
+                message="OAuth access token user has no accessible workspace",
+            )
+
+        ws_id = self._coerce_positive_int(workspace.get("wsId"))
+        if ws_id is None:
+            raise QingflowApiError(
+                category="auth",
+                message="OAuth access token user has no valid workspace",
+            )
+        if self._resolve_workspace_qf_version(workspace)[0] is None:
+            try:
+                workspace_response = self.backend.request_with_meta(
+                    "GET",
+                    self._request_context(access_token, ws_id, response_qf_version),
+                    f"/user/workspace/{ws_id}",
+                )
+                workspace = self._as_object(workspace_response.data) or workspace
+                response_qf_version = (
+                    workspace_response.qf_response_version or response_qf_version
+                )
+            except QingflowApiError as error:
+                if is_auth_like_error(error):
+                    raise
+        return user_info, workspace, response_qf_version
+
+    def _fetch_first_workspace(
+        self, access_token: str
+    ) -> tuple[JSONObject | None, str | None]:
+        response = self.backend.request_with_meta(
+            "POST",
+            self._request_context(access_token, None),
+            "/user/workspaceList/pageQuery",
+            json_body={"pageNum": 1, "pageSize": 1},
+        )
+        page = self._as_object(response.data)
+        workspaces = page.get("list") if page else None
+        first = workspaces[0] if isinstance(workspaces, list) and workspaces else None
+        return self._as_object(first), response.qf_response_version
+
+    def _request_context(
+        self,
+        access_token: str,
+        ws_id: int | None,
+        qf_version: str | None = None,
+    ) -> BackendRequestContext:
+        return BackendRequestContext(
+            base_url=self.base_url,
+            token=access_token,
+            ws_id=ws_id,
+            qf_version=qf_version or self.qf_version,
+            qf_version_source=(
+                "backend_response"
+                if qf_version
+                else "default_config"
+                if self.qf_version
+                else None
+            ),
+        )
+
+    @staticmethod
+    def _as_object(value: Any) -> JSONObject | None:
+        return value if isinstance(value, dict) else None
+
+    @classmethod
+    def _resolve_workspace_qf_version(
+        cls, workspace: JSONObject
+    ) -> tuple[str | None, str | None]:
+        qf_version = cls._normalize_text(workspace.get("qfVersion"))
+        if qf_version is not None:
+            return qf_version, "workspace_qf_version"
+        system_version = cls._normalize_text(workspace.get("systemVersion"))
+        if system_version is not None:
+            return system_version, "workspace_system_version"
+        return None, None
+
+    @staticmethod
+    def _normalize_text(value: Any) -> str | None:
+        if value is None:
+            return None
+        text = str(value).strip()
+        return text or None
+
+    @staticmethod
+    def _coerce_positive_int(value: Any) -> int | None:
+        if isinstance(value, bool) or value is None:
+            return None
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            return None
+        return parsed if parsed > 0 else None
+
+
+def _validate_resource_url(value: str) -> str:
+    parsed = urlsplit(value)
+    is_loopback_http = parsed.scheme == "http" and parsed.hostname in {
+        "localhost",
+        "127.0.0.1",
+        "::1",
+    }
+    if not parsed.netloc or (parsed.scheme != "https" and not is_loopback_http):
+        raise QingflowApiError.config_error(
+            "cloud.oauth.resource_url must use HTTPS (HTTP is allowed for loopback)"
+        )
+    if parsed.query or parsed.fragment or parsed.username or parsed.password:
+        raise QingflowApiError.config_error(
+            "cloud.oauth.resource_url must not contain user info, query parameters, or a fragment"
+        )
+    return normalize_base_url(value) or value.rstrip("/")

package/src/qingflow_mcp/cloud_redis.py

@@ -20,6 +20,9 @@ class CloudAuthCache(Protocol):
     def get_json(self, key: str) -> JSONObject | None:
         ...
 
+    def get_text(self, key: str) -> str | None:
+        ...
+
     def set_json(self, key: str, value: JSONObject, ttl_seconds: int) -> None:
         ...
 
@@ -72,6 +75,28 @@ class RedisCloudAuthCache:
             raise QingflowApiError(category="cache", message=f"invalid Redis JSON for key '{key}': {exc}") from exc
         return value if isinstance(value, dict) else None
 
+    def get_text(self, key: str) -> str | None:
+        try:
+            raw_value = self._client.get(key)
+        except Exception as exc:
+            raise QingflowApiError(
+                category="cache",
+                message="failed to read text value from Redis",
+            ) from exc
+        if raw_value is None:
+            return None
+        if isinstance(raw_value, bytes):
+            try:
+                raw_value = raw_value.decode("utf-8")
+            except UnicodeDecodeError:
+                return None
+        text = str(raw_value)
+        try:
+            value = json.loads(text)
+        except json.JSONDecodeError:
+            value = text
+        return value if isinstance(value, str) else None
+
     def set_json(self, key: str, value: JSONObject, ttl_seconds: int) -> None:
         self._client.set(key, json.dumps(value, ensure_ascii=False), ex=max(1, int(ttl_seconds)))
 

package/src/qingflow_mcp/config.py

@@ -301,6 +301,50 @@ def get_cloud_auth_context_lock_wait_seconds() -> float:
     return parsed if parsed > 0 else DEFAULT_CLOUD_AUTH_CONTEXT_LOCK_WAIT_SECONDS
 
 
+def get_cloud_oauth_service_base_url() -> str | None:
+    value = get_config_value(
+        "cloud.oauth.service_base_url",
+        env_var="QINGFLOW_MCP_OAUTH_SERVICE_BASE_URL",
+        default=None,
+    )
+    normalized = normalize_base_url(str(value).strip()) if value is not None else None
+    if normalized:
+        return normalized
+    _, service_base_url = _derive_cloud_oauth_urls()
+    return service_base_url
+
+
+def get_cloud_oauth_resource_url() -> str | None:
+    value = get_config_value(
+        "cloud.oauth.resource_url",
+        env_var="QINGFLOW_MCP_OAUTH_RESOURCE_URL",
+        default=None,
+    )
+    normalized = str(value or "").strip().rstrip("/")
+    if normalized:
+        return normalized
+    resource_url, _ = _derive_cloud_oauth_urls()
+    return resource_url
+
+
+def _derive_cloud_oauth_urls() -> tuple[str | None, str | None]:
+    default_base_url = get_default_base_url()
+    if default_base_url is None:
+        return None, None
+
+    parsed = urlsplit(default_base_url)
+    path = parsed.path.rstrip("/")
+    if path.endswith("/api"):
+        resource_path = path[:-4]
+    else:
+        resource_path = path
+
+    resource_url = urlunsplit(
+        (parsed.scheme, parsed.netloc, resource_path, parsed.query, parsed.fragment)
+    )
+    return resource_url or None, default_base_url
+
+
 def get_cloud_http_host() -> str:
     value = get_config_value(
         "cloud.http.host",

package/src/qingflow_mcp/server_app_user.py

@@ -22,11 +22,12 @@ from .tools.task_context_tools import TaskContextTools
 from .tools.workspace_tools import WorkspaceTools
 
 
-def build_user_server() -> FastMCP:
+def build_user_server(*, stateless_http: bool = False) -> FastMCP:
     today = date.today()
     current_year = today.year
     server = FastMCP(
         "Qingflow App User MCP",
+        stateless_http=stateless_http,
         instructions=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
 
 ## App Discovery

package/src/qingflow_mcp/server_cloud.py

@@ -10,7 +10,13 @@ from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .cloud_auth import CloudAuthBroker
-from .cloud_context import current_cloud_context
+from .cloud_context import CloudMcpContext, current_call_platform, current_cloud_context
+from .cloud_oauth_proxy import (
+    CloudOAuthProxyConfig,
+    OAuthAccessTokenResolver,
+    OAuthProxyResponse,
+    OAuthServiceProxy,
+)
 from .config import get_cloud_http_allowed_hosts, get_cloud_http_host, get_cloud_http_port
 from .errors import QingflowApiError, is_auth_like_error
 from .server_app_builder import build_builder_server
@@ -36,11 +42,15 @@ class CloudMcpAuthApp:
         app: ASGIApp,
         broker: CloudAuthBroker,
         *,
+        oauth_proxy: OAuthServiceProxy | None = None,
+        oauth_token_resolver: OAuthAccessTokenResolver | None = None,
         allowed_hosts: list[str] | None = None,
         internal_host: str | None = None,
     ) -> None:
         self._app = app
         self._broker = broker
+        self._oauth_proxy = oauth_proxy
+        self._oauth_token_resolver = oauth_token_resolver
         self._allowed_hosts = [
             host.strip().lower()
             for host in (allowed_hosts if allowed_hosts is not None else get_cloud_http_allowed_hosts())
@@ -69,22 +79,43 @@ class CloudMcpAuthApp:
             await self._json_response(send, 200, {"status": "ok"})
             return
 
-        credential = self._extract_credential(scope)
-        if credential is None:
-            await self._json_response(
-                send,
-                401,
-                {
-                    "error": "missing_mcp_credential",
-                    "message": "Authorization: Bearer <mcp_credential> is required",
-                },
-            )
+        if self._oauth_proxy is not None:
+            backend_metadata_path = self._oauth_proxy.config.backend_metadata_path(path)
+            if backend_metadata_path is not None:
+                await self._proxy_oauth_metadata(
+                    scope,
+                    send,
+                    backend_metadata_path,
+                )
+                return
+
+        auth_value, explicit_credential, call_platform = self._extract_auth_value(scope)
+        if auth_value is None:
+            await self._authentication_required(send)
             return
 
+        use_oauth = (
+            not explicit_credential
+            and self._oauth_token_resolver is not None
+            and not auth_value.startswith("mcp_")
+        )
         try:
-            cloud_context = await anyio.to_thread.run_sync(self._broker.resolve, credential)
+            if use_oauth:
+                assert self._oauth_token_resolver is not None
+                cloud_context = await anyio.to_thread.run_sync(
+                    self._resolve_oauth_or_legacy_credential,
+                    auth_value,
+                )
+            else:
+                cloud_context = await anyio.to_thread.run_sync(
+                    self._broker.resolve,
+                    auth_value,
+                )
         except QingflowApiError as error:
             status = 401 if is_auth_like_error(error) else 500
+            if status == 401 and use_oauth:
+                await self._oauth_authentication_required(send, "invalid_token", error.message)
+                return
             await self._json_response(
                 send,
                 status,
@@ -97,30 +128,119 @@ class CloudMcpAuthApp:
             )
             return
 
-        token = current_cloud_context.set(cloud_context)
+        if not call_platform:
+            call_platform = await anyio.to_thread.run_sync(
+                self._broker.resolve_call_platform,
+                cloud_context.token,
+            )
+
+        context_token = current_cloud_context.set(cloud_context)
+        call_platform_token = current_call_platform.set(call_platform)
         try:
             scope = _ensure_streamable_http_accept(scope)
             await self._app(scope, receive, send)
         finally:
-            current_cloud_context.reset(token)
+            current_call_platform.reset(call_platform_token)
+            current_cloud_context.reset(context_token)
 
-    def _extract_credential(self, scope: dict[str, Any]) -> str | None:
+    def _resolve_oauth_or_legacy_credential(self, auth_value: str) -> CloudMcpContext:
+        assert self._oauth_token_resolver is not None
+        try:
+            return self._oauth_token_resolver.resolve(auth_value)
+        except QingflowApiError as oauth_error:
+            if not is_auth_like_error(oauth_error):
+                raise
+            try:
+                return self._broker.resolve(auth_value)
+            except QingflowApiError:
+                raise oauth_error
+
+    def _extract_auth_value(self, scope: dict[str, Any]) -> tuple[str | None, bool, str]:
         headers = {
             key.decode("latin1").lower(): value.decode("latin1")
             for key, value in scope.get("headers", [])
         }
+        call_platform = headers.get("x-qf-callplatform", "").strip()
         authorization = headers.get("authorization", "")
         if authorization.lower().startswith("bearer "):
-            credential = authorization[7:].strip()
-            return credential or None
+            bearer_token = authorization[7:].strip()
+            return bearer_token or None, False, call_platform
         credential = headers.get("x-qingflow-client-id", "").strip()
-        return credential or None
+        return credential or None, True, call_platform
+
+    async def _authentication_required(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+    ) -> None:
+        if self._oauth_proxy is not None:
+            await self._oauth_authentication_required(
+                send,
+                "invalid_token",
+                "Authentication required",
+            )
+            return
+        await self._json_response(
+            send,
+            401,
+            {
+                "error": "missing_mcp_credential",
+                "message": "Authorization: Bearer <mcp_credential> is required",
+            },
+        )
+
+    async def _oauth_authentication_required(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        error: str,
+        description: str,
+    ) -> None:
+        assert self._oauth_proxy is not None
+        challenge = (
+            f'Bearer error="{_escape_auth_param(error)}", '
+            f'error_description="{_escape_auth_param(description)}", '
+            f'resource_metadata="{self._oauth_proxy.config.resource_metadata_url}"'
+        )
+        await self._json_response(
+            send,
+            401,
+            {"error": error, "error_description": description},
+            extra_headers=[
+                (b"www-authenticate", challenge.encode("latin1", errors="replace")),
+                (b"cache-control", b"no-store"),
+                (b"pragma", b"no-cache"),
+            ],
+        )
+
+    async def _proxy_oauth_metadata(
+        self,
+        scope: dict[str, Any],
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        backend_path: str,
+    ) -> None:
+        assert self._oauth_proxy is not None
+        try:
+            response = await anyio.to_thread.run_sync(
+                self._oauth_proxy.request_metadata,
+                str(scope.get("method") or "GET"),
+                backend_path,
+                bytes(scope.get("query_string") or b""),
+            )
+        except QingflowApiError as error:
+            await self._json_response(
+                send,
+                502,
+                {"error": "oauth_service_unavailable", "message": error.message},
+            )
+            return
+        await self._raw_response(send, response)
 
     async def _json_response(
         self,
         send: Callable[[dict[str, Any]], Awaitable[None]],
         status: int,
         payload: dict[str, Any],
+        *,
+        extra_headers: list[tuple[bytes, bytes]] | None = None,
     ) -> None:
         body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
         await send(
@@ -130,11 +250,26 @@ class CloudMcpAuthApp:
                 "headers": [
                     (b"content-type", b"application/json; charset=utf-8"),
                     (b"content-length", str(len(body)).encode("ascii")),
-                ],
+                ] + list(extra_headers or []),
             }
         )
         await send({"type": "http.response.body", "body": body})
 
+    async def _raw_response(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        response: OAuthProxyResponse,
+    ) -> None:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": response.status_code,
+                "headers": list(response.headers)
+                + [(b"content-length", str(len(response.body)).encode("ascii"))],
+            }
+        )
+        await send({"type": "http.response.body", "body": response.body})
+
     async def _plain_response(
         self,
         send: Callable[[dict[str, Any]], Awaitable[None]],
@@ -176,12 +311,25 @@ def build_cloud_user_app() -> CloudMcpAuthApp:
 
 def build_cloud_app() -> CloudMcpAuthApp:
     server = build_combined_server()
-    broker = CloudAuthBroker.from_config(backend=BackendClient())
-    return CloudMcpAuthApp(server.streamable_http_app(), broker)
+    backend = BackendClient()
+    broker = CloudAuthBroker.from_config(backend=backend)
+    oauth_config = CloudOAuthProxyConfig.from_config()
+    oauth_proxy = OAuthServiceProxy(oauth_config) if oauth_config is not None else None
+    oauth_token_resolver = (
+        OAuthAccessTokenResolver.from_config(backend)
+        if oauth_config is not None
+        else None
+    )
+    return CloudMcpAuthApp(
+        server.streamable_http_app(),
+        broker,
+        oauth_proxy=oauth_proxy,
+        oauth_token_resolver=oauth_token_resolver,
+    )
 
 
 def build_combined_server() -> FastMCP:
-    server = build_user_server()
+    server = build_user_server(stateless_http=True)
     builder_server = build_builder_server()
     server._mcp_server.name = "Qingflow Combined MCP"
     _register_prefixed_builder_tools(server, builder_server)
@@ -308,6 +456,16 @@ def _ensure_streamable_http_accept(scope: dict[str, Any]) -> dict[str, Any]:
     return rewritten
 
 
+def _escape_auth_param(value: str) -> str:
+    return (
+        str(value or "")
+        .replace("\\", "\\\\")
+        .replace('"', '\\"')
+        .replace("\r", " ")
+        .replace("\n", " ")
+    )
+
+
 app = LazyCloudApp()
 
 

package/src/qingflow_mcp/session_store.py

@@ -105,7 +105,7 @@ class SessionStore:
         persist: bool,
     ) -> SessionProfile:
         now = _utcnow()
-        previous = self.get_profile(profile)
+        previous = self.peek_profile(profile)
         persisted = False
         if persist:
             persisted = self._set_secret(self._token_key(profile), token)
@@ -163,6 +163,12 @@ class SessionStore:
             session_profile = SessionProfile.from_dict(raw_profile) if isinstance(raw_profile, dict) else None
         return session_profile
 
+    def peek_profile(self, profile: str) -> SessionProfile | None:
+        """读取 profile，但不触发缺失、过期会话的自动刷新。"""
+        payload = self._load_profiles()
+        raw_profile = payload.get("profiles", {}).get(profile)
+        return SessionProfile.from_dict(raw_profile) if isinstance(raw_profile, dict) else None
+
     def get_backend_session(self, profile: str) -> BackendSession | None:
         if profile in self._logged_out_profiles:
             return None

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
 
@@ -85,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,
         )
@@ -306,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
 
@@ -317,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]:
@@ -355,15 +366,12 @@ 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):

package/src/qingflow_mcp/tools/base.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import os
 from contextvars import ContextVar
 from typing import Any, Callable, TypeVar
 
 from ..backend_client import BackendRequestContext, BackendClient
-from ..cloud_context import current_cloud_context
+from ..cloud_context import current_call_platform, current_cloud_context
 from ..config import (
     get_credit_meter_enabled,
     get_credit_usage_base_url,
@@ -29,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)
@@ -151,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):
@@ -265,6 +323,7 @@ class ToolBase:
                 "scene": "MCP",
                 "aiBiz": "MCP",
                 "extraInfo": tool_name,
+                "callPlatform": current_call_platform.get(),
             },
         )
 

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -535,6 +535,10 @@ class TaskContextTools(ToolBase):
                     task_context=task_context,
                     fields=field_updates,
                 )
+            elif normalized_action == "transfer" and body.get("answers") is None:
+                record = task_context.get("record") if isinstance(task_context.get("record"), dict) else {}
+                current_answers = record.get("answers") if isinstance(record.get("answers"), list) else []
+                prepared_fields = {"merged_answers": current_answers}
             before_apply_status = ((task_context.get("record") or {}).get("apply_status"))
             runtime_baseline = None
             if normalized_action != "save_only":
@@ -704,6 +708,8 @@ class TaskContextTools(ToolBase):
                 action_payload["auditFeedback"] = audit_feedback
             if merged_answers is not None:
                 action_payload["answers"] = merged_answers
+            elif payload.get("answers") is not None:
+                action_payload["answers"] = payload["answers"]
             return self._approval_tools.record_transfer(
                 profile=profile,
                 app_key=app_key,