@josephyan/qingflow-cli 0.2.0-beta.57 → 0.2.0-beta.59

package/src/qingflow_mcp/tools/solution_tools.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
+import json
 from typing import Any
 from uuid import uuid4
 
@@ -8,6 +9,7 @@ from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, ValidationError
 
 from ..config import DEFAULT_PROFILE
+from ..errors import QingflowApiError
 from ..list_type_labels import get_record_list_type_label
 from ..solution.build_assembly_store import BuildAssemblyStore, default_manifest
 from ..solution.compiler import CompiledSolution, ExecutionPlan, ExecutionStep, build_execution_plan, compile_solution
@@ -1850,7 +1852,15 @@ class SolutionTools(ToolBase):
         packages = PackageTools(self.sessions, self.backend)
         normalized_name = package_name.strip()
         if package_tag_id > 0:
-            result = packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=False)
+            try:
+                result = packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=False)
+            except (QingflowApiError, RuntimeError) as exc:
+                return _builder_package_resolution_failed(
+                    package_name=normalized_name,
+                    package_tag_id=package_tag_id,
+                    error=_coerce_solution_api_error(exc),
+                    retried=False,
+                )
             summary = result.get("result") if isinstance(result.get("result"), dict) else {}
             return {
                 "status": "resolved",
@@ -1869,12 +1879,28 @@ class SolutionTools(ToolBase):
                 "source_shape": None,
                 "retried": False,
             }
-        result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        try:
+            result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        except (QingflowApiError, RuntimeError) as exc:
+            return _builder_package_resolution_failed(
+                package_name=normalized_name,
+                package_tag_id=package_tag_id,
+                error=_coerce_solution_api_error(exc),
+                retried=False,
+            )
         items = result.get("items") if isinstance(result.get("items"), list) else []
         source_shape = result.get("source_shape")
         retried = False
         if not items:
-            retry_result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+            try:
+                retry_result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+            except (QingflowApiError, RuntimeError) as exc:
+                return _builder_package_resolution_failed(
+                    package_name=normalized_name,
+                    package_tag_id=package_tag_id,
+                    error=_coerce_solution_api_error(exc),
+                    retried=True,
+                )
             retry_items = retry_result.get("items") if isinstance(retry_result.get("items"), list) else []
             if retry_items:
                 items = retry_items
@@ -2982,6 +3008,72 @@ def _solution_error_fields(
     }
 
 
+def _builder_package_resolution_failed(
+    *,
+    package_name: str,
+    package_tag_id: int,
+    error: QingflowApiError,
+    retried: bool,
+) -> dict[str, Any]:
+    if package_tag_id > 0:
+        detail = f"failed to resolve package_tag_id '{package_tag_id}': {error.message}"
+    elif error.backend_code in {40002, 40027}:
+        detail = (
+            f"failed to resolve package '{package_name}' because package listing is permission-restricted; "
+            "provide package_tag_id explicitly or use an account that can list packages"
+        )
+    else:
+        detail = f"failed to resolve package '{package_name}': {error.message}"
+    error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+    error_fields["error_code"] = "PACKAGE_RESOLVE_FAILED"
+    return {
+        "status": "failed",
+        "response": {
+            "status": "failed",
+            "mode": "plan",
+            "stage": "app",
+            "errors": [{"category": "config", "detail": detail}],
+            "package_resolution": {
+                "status": "failed",
+                "requested_name": package_name or None,
+                "requested_tag_id": package_tag_id or None,
+                "resolution_policy": "exact_name_only" if package_name else "tag_id_only",
+                "candidates": [],
+                "source_shape": None,
+                "retried": retried,
+                "transport_error": {
+                    "http_status": error.http_status,
+                    "backend_code": error.backend_code,
+                    "category": error.category,
+                    "request_id": error.request_id,
+                },
+            },
+            **error_fields,
+        },
+    }
+
+
+def _coerce_solution_api_error(error: Exception) -> QingflowApiError:
+    if isinstance(error, QingflowApiError):
+        return error
+    if isinstance(error, RuntimeError):
+        try:
+            payload = json.loads(str(error))
+        except json.JSONDecodeError:
+            payload = None
+        if isinstance(payload, dict) and payload.get("category") and payload.get("message"):
+            details = payload.get("details")
+            return QingflowApiError(
+                category=str(payload.get("category")),
+                message=str(payload.get("message")),
+                backend_code=payload.get("backend_code"),
+                request_id=payload.get("request_id"),
+                http_status=payload.get("http_status"),
+                details=details if isinstance(details, dict) else None,
+            )
+    return QingflowApiError(category="runtime", message=str(error))
+
+
 def _coerce_count(value: Any) -> int | None:
     if isinstance(value, bool) or value is None:
         return None

package/src/qingflow_mcp/ops/__init__.py

@@ -1,3 +0,0 @@
-from .context import OperationsRuntime, build_operations_runtime
-
-__all__ = ["OperationsRuntime", "build_operations_runtime"]

package/src/qingflow_mcp/ops/apps.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result
-
-
-class AppOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def list(self, *, profile: str) -> dict:
-        try:
-            raw = self._tools.app.app_list(profile=profile)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        items = raw.get("items") if isinstance(raw.get("items"), list) else []
-        return success_result(
-            "APPS_LISTED",
-            "已读取应用列表",
-            data={"items": items, "count": raw.get("count", len(items))},
-            meta={"profile": profile, "workspace_id": raw.get("ws_id")},
-            legacy=raw,
-        )
-
-    def find(self, *, profile: str, keyword: str, page_num: int, page_size: int) -> dict:
-        try:
-            raw = self._tools.app.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "APPS_FOUND",
-            "已完成应用搜索",
-            data={
-                "items": raw.get("items") if isinstance(raw.get("items"), list) else [],
-                "total": raw.get("total"),
-                "keyword": keyword,
-                "page_num": page_num,
-                "page_size": page_size,
-            },
-            meta={"profile": profile, "workspace_id": raw.get("ws_id")},
-            legacy=raw,
-        )
-
-    def show(self, *, profile: str, app_key: str) -> dict:
-        try:
-            raw = self._tools.app.app_get(profile=profile, app_key=app_key)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = raw.get("data") if isinstance(raw.get("data"), dict) else {}
-        return success_result(
-            "APP_SHOWN",
-            "已读取应用信息",
-            data={
-                "app_key": data.get("app_key", app_key),
-                "app_name": data.get("app_name"),
-                "can_create": data.get("can_create"),
-                "import_capability": data.get("import_capability"),
-                "accessible_views": data.get("accessible_views") if isinstance(data.get("accessible_views"), list) else [],
-            },
-            warnings=raw.get("warnings") if isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "workspace_id": raw.get("ws_id"), "request_route": raw.get("request_route")},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/auth.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result
-
-
-class AuthOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def login(
-        self,
-        *,
-        profile: str,
-        base_url: str | None,
-        qf_version: str | None,
-        email: str,
-        password: str,
-        persist: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.auth.auth_login(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                email=email,
-                password=password,
-                persist=persist,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "AUTHENTICATED",
-            "登录成功",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def use_token(
-        self,
-        *,
-        profile: str,
-        base_url: str | None,
-        qf_version: str | None,
-        token: str,
-        ws_id: int | None,
-        persist: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.auth.auth_use_token(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                token=token,
-                ws_id=ws_id,
-                persist=persist,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TOKEN_ACCEPTED",
-            "已接入会话令牌",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def me(self, *, profile: str) -> dict:
-        try:
-            raw = self._tools.auth.auth_whoami(profile=profile)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "SESSION_READY",
-            "当前会话已就绪",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def logout(self, *, profile: str, forget_persisted: bool) -> dict:
-        try:
-            raw = self._tools.auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "SESSION_CLEARED",
-            "已退出当前会话",
-            data={
-                "profile": raw.get("profile", profile),
-                "logged_out": bool(raw.get("logged_out", True)),
-                "forgot_persisted": bool(raw.get("forgot_persisted", forget_persisted)),
-            },
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-
-def _auth_payload(raw: dict) -> dict:
-    return {
-        "profile": raw.get("profile"),
-        "base_url": raw.get("base_url"),
-        "qf_version": raw.get("qf_version"),
-        "qf_version_source": raw.get("qf_version_source"),
-        "user": {
-            "uid": raw.get("uid"),
-            "email": raw.get("email"),
-            "nick_name": raw.get("nick_name"),
-        },
-        "workspace": {
-            "ws_id": raw.get("selected_ws_id"),
-            "name": raw.get("selected_ws_name"),
-        },
-        "suggested_workspace": {
-            "ws_id": raw.get("suggested_ws_id"),
-            "name": raw.get("suggested_ws_name"),
-        },
-        "persisted": bool(raw.get("persisted")),
-    }

package/src/qingflow_mcp/ops/base.py

@@ -1,290 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from ..errors import QingflowApiError
-from ..json_types import JSONObject
-
-
-_COMMON_KEYS = {
-    "ok",
-    "status",
-    "message",
-    "error_code",
-    "details",
-    "warnings",
-    "verification",
-    "profile",
-    "ws_id",
-    "request_id",
-    "request_route",
-    "output_profile",
-    "recoverable",
-    "missing_fields",
-    "allowed_values",
-    "suggested_next_call",
-    "noop",
-    "compact",
-    "summary",
-}
-
-_INTERNAL_LEGACY_KEY = "__legacy__"
-
-
-def success_result(
-    code: str,
-    message: str,
-    *,
-    data: Any = None,
-    warnings: list[Any] | None = None,
-    meta: JSONObject | None = None,
-    legacy: Any = None,
-) -> JSONObject:
-    payload: JSONObject = {
-        "ok": True,
-        "code": code,
-        "message": message,
-        "data": data if data is not None else {},
-        "warnings": list(warnings or []),
-        "meta": dict(meta or {}),
-    }
-    if legacy is not None:
-        payload[_INTERNAL_LEGACY_KEY] = legacy
-    return payload
-
-
-def error_result(
-    code: str,
-    message: str,
-    *,
-    details: Any = None,
-    suggested_next: Any = None,
-    meta: JSONObject | None = None,
-    legacy: Any = None,
-) -> JSONObject:
-    payload: JSONObject = {
-        "ok": False,
-        "code": code,
-        "message": message,
-        "details": details if details is not None else {},
-        "meta": dict(meta or {}),
-    }
-    if suggested_next is not None:
-        payload["suggested_next"] = suggested_next
-    if legacy is not None:
-        payload[_INTERNAL_LEGACY_KEY] = legacy
-    return payload
-
-
-def build_meta(raw: Any, *, extra: JSONObject | None = None) -> JSONObject:
-    meta: JSONObject = {}
-    if isinstance(raw, dict):
-        if raw.get("profile") is not None:
-            meta["profile"] = raw.get("profile")
-        if raw.get("ws_id") is not None:
-            meta["workspace_id"] = raw.get("ws_id")
-        if raw.get("request_id") is not None:
-            meta["request_id"] = raw.get("request_id")
-        if isinstance(raw.get("request_route"), dict):
-            meta["request_route"] = raw.get("request_route")
-        if isinstance(raw.get("verification"), dict) and raw.get("verification"):
-            meta["verification"] = raw.get("verification")
-    if extra:
-        meta.update(extra)
-    return meta
-
-
-def collect_warnings(raw: Any) -> list[Any]:
-    warnings: list[Any] = []
-    if isinstance(raw, dict):
-        if isinstance(raw.get("warnings"), list):
-            warnings.extend(raw["warnings"])
-        status = str(raw.get("status") or "").lower()
-        if status == "partial_success":
-            warnings.append(
-                {
-                    "code": "PARTIAL_SUCCESS",
-                    "message": str(raw.get("message") or "operation completed with warnings"),
-                }
-            )
-    return warnings
-
-
-def tool_payload(raw: Any) -> Any:
-    if not isinstance(raw, dict):
-        return raw
-    if "data" in raw:
-        return raw.get("data")
-    if "items" in raw:
-        return {
-            "items": raw.get("items") if isinstance(raw.get("items"), list) else [],
-            "count": raw.get("count"),
-        }
-    if "page" in raw:
-        page = raw.get("page")
-        if isinstance(page, dict):
-            return {
-                "items": page.get("list") if isinstance(page.get("list"), list) else [],
-                "page": page,
-            }
-    if "result" in raw:
-        return raw.get("result")
-    return {key: value for key, value in raw.items() if key not in _COMMON_KEYS}
-
-
-def is_failed_tool_result(raw: Any) -> bool:
-    if not isinstance(raw, dict):
-        return False
-    if raw.get("ok") is False:
-        return True
-    status = str(raw.get("status") or "").lower()
-    return status in {"failed", "blocked"}
-
-
-def tool_result_to_cli(
-    raw: Any,
-    *,
-    code: str,
-    message: str,
-    data: Any = None,
-    meta: JSONObject | None = None,
-) -> JSONObject:
-    if is_failed_tool_result(raw):
-        payload = normalize_tool_error(raw)
-        payload["meta"] = build_meta(raw, extra=meta)
-        return payload
-    return success_result(
-        code,
-        message,
-        data=tool_payload(raw) if data is None else data,
-        warnings=collect_warnings(raw),
-        meta=build_meta(raw, extra=meta),
-    )
-
-
-def normalize_tool_error(raw: Any) -> JSONObject:
-    if isinstance(raw, dict):
-        details = raw.get("details")
-        if not isinstance(details, dict):
-            details = {}
-        if raw.get("backend_code") is not None:
-            details.setdefault("backend_code", raw.get("backend_code"))
-        if raw.get("request_id") is not None:
-            details.setdefault("request_id", raw.get("request_id"))
-        if raw.get("verification") not in (None, {}):
-            details.setdefault("verification", raw.get("verification"))
-        return error_result(
-            str(raw.get("error_code") or raw.get("code") or raw.get("category") or "OPERATION_FAILED"),
-            str(raw.get("message") or "operation failed"),
-            details=details,
-            suggested_next=raw.get("suggested_next_call"),
-            legacy=raw,
-        )
-    return error_result("OPERATION_FAILED", str(raw))
-
-
-def coerce_runtime_error(exc: RuntimeError) -> QingflowApiError:
-    raw = str(exc)
-    try:
-        payload = json.loads(raw)
-    except json.JSONDecodeError:
-        return QingflowApiError(category="runtime", message=raw)
-    if not isinstance(payload, dict):
-        return QingflowApiError(category="runtime", message=raw)
-    return QingflowApiError(
-        category=str(payload.get("category") or "runtime"),
-        message=str(payload.get("message") or raw),
-        backend_code=payload.get("backend_code"),
-        request_id=payload.get("request_id"),
-        details=payload.get("details") if isinstance(payload.get("details"), dict) else None,
-    )
-
-
-def normalize_exception(error: Exception) -> JSONObject:
-    if isinstance(error, RuntimeError):
-        api_error = coerce_runtime_error(error)
-    elif isinstance(error, QingflowApiError):
-        api_error = error
-    else:
-        return error_result("RUNTIME_ERROR", str(error))
-
-    details = dict(api_error.details or {})
-    if api_error.backend_code is not None:
-        details.setdefault("backend_code", api_error.backend_code)
-    if api_error.request_id is not None:
-        details.setdefault("request_id", api_error.request_id)
-    code = str(details.pop("error_code", None) or api_error.category or "OPERATION_FAILED").upper()
-    if code == "CONFIG":
-        code = "INVALID_ARGUMENT"
-    elif code == "AUTH":
-        code = "AUTH_REQUIRED"
-    elif code == "WORKSPACE":
-        code = "WORKSPACE_NOT_SELECTED"
-    legacy_payload = None
-    if isinstance(error, RuntimeError):
-        raw = str(error)
-        try:
-            parsed = json.loads(raw)
-        except json.JSONDecodeError:
-            parsed = None
-        if isinstance(parsed, dict):
-            legacy_payload = parsed
-    return error_result(code, api_error.message, details=details, legacy=legacy_payload)
-
-
-def public_result(payload: Any) -> Any:
-    if isinstance(payload, dict):
-        return {
-            key: public_result(value)
-            for key, value in payload.items()
-            if key != _INTERNAL_LEGACY_KEY
-        }
-    if isinstance(payload, list):
-        return [public_result(item) for item in payload]
-    return payload
-
-
-def mcp_result_from_operation(result: Any) -> Any:
-    if not isinstance(result, dict):
-        return result
-    legacy = result.get(_INTERNAL_LEGACY_KEY)
-    if isinstance(legacy, dict):
-        return legacy
-    meta = result.get("meta") if isinstance(result.get("meta"), dict) else {}
-    if result.get("ok") is False:
-        payload: JSONObject = {
-            "ok": False,
-            "status": "failed",
-            "error_code": result.get("code") or "OPERATION_FAILED",
-            "message": result.get("message") or "operation failed",
-            "details": result.get("details") if isinstance(result.get("details"), dict) else {},
-            "warnings": result.get("warnings") if isinstance(result.get("warnings"), list) else [],
-        }
-        if isinstance(meta.get("request_route"), dict):
-            payload["request_route"] = meta["request_route"]
-        if isinstance(meta.get("verification"), dict):
-            payload["verification"] = meta["verification"]
-        if meta.get("profile") is not None:
-            payload["profile"] = meta.get("profile")
-        if meta.get("workspace_id") is not None:
-            payload["ws_id"] = meta.get("workspace_id")
-        if result.get("suggested_next") is not None:
-            payload["suggested_next_call"] = result.get("suggested_next")
-        return payload
-    payload = {
-        "ok": True,
-        "status": "success",
-        "message": result.get("message") or "ok",
-        "data": result.get("data"),
-        "warnings": result.get("warnings") if isinstance(result.get("warnings"), list) else [],
-    }
-    if isinstance(meta.get("request_route"), dict):
-        payload["request_route"] = meta["request_route"]
-    if isinstance(meta.get("verification"), dict):
-        payload["verification"] = meta["verification"]
-    if meta.get("profile") is not None:
-        payload["profile"] = meta.get("profile")
-    if meta.get("workspace_id") is not None:
-        payload["ws_id"] = meta.get("workspace_id")
-    return payload