@josephyan/qingflow-app-builder-mcp 0.2.0-beta.73 → 0.2.0-beta.74

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.73
+npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.74
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.73 qingflow-app-builder-mcp
+npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.74 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.73",
+  "version": "0.2.0-beta.74",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/skills/qingflow-app-builder/SKILL.md

@@ -61,7 +61,7 @@ Note:
 - `portal_apply` uses replace semantics for sections; remove a section by omitting it from the next full sections list. `publish=false` only guarantees draft/base-info updates, and `chart_ref/view_ref` resolve by `id/key` first and exact unique name second.
 - `app_get_charts` is the compact discovery path for current chart inventory; use it before `app_charts_apply` when you need exact `chart_id` values.
 - `chart_get` returns one chart's base info and config only; public builder flows should treat data reads as user-side access, not builder config access.
-- `portal_list` is the discovery path for accessible portals.
+- `portal_list` is the discovery path for builder-configurable portals.
 - `portal_get` returns portal-level config detail plus a component inventory; it does not inline chart/view detail or user-side chart/view data.
 - `view_get` returns one view's definition detail only; use `record_list` separately when you need rows from that view.
 - `app_schema_apply` / `app_layout_apply` / `app_flow_apply` / `app_views_apply` now perform planning, normalization, and dependency checks internally; when prechecks block, read the returned blocking issues and `suggested_next_call` directly from the apply result.

package/src/qingflow_mcp/backend_client.py

@@ -88,6 +88,30 @@ class BackendClient:
             unwrap=unwrap,
         )
 
+    def public_request_with_headers(
+        self,
+        method: str,
+        base_url: str,
+        path: str,
+        *,
+        params: JSONObject | None = None,
+        json_body: JSONValue = None,
+        unwrap: bool = True,
+        qf_version: str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> BackendResponse:
+        request_headers = self._base_headers(None, None, qf_version=qf_version)
+        if headers:
+            request_headers.update({key: value for key, value in headers.items() if value is not None})
+        return self._request_with_meta(
+            method,
+            self._build_url(base_url, path),
+            params=params,
+            json_body=json_body,
+            headers=request_headers,
+            unwrap=unwrap,
+        )
+
     def request(
         self,
         method: str,
@@ -131,6 +155,54 @@ class BackendClient:
             unwrap=unwrap,
         )
 
+    def stream_request(
+        self,
+        method: str,
+        context: BackendRequestContext,
+        path: str,
+        *,
+        params: JSONObject | None = None,
+        json_body: JSONValue = None,
+        headers: dict[str, str] | None = None,
+    ) -> list[str]:
+        request_headers = self._base_headers(
+            context.token,
+            context.ws_id,
+            context.qf_request_id,
+            qf_version=context.qf_version,
+        )
+        if headers:
+            request_headers.update({key: value for key, value in headers.items() if value is not None})
+        return self._stream_lines(
+            method,
+            self._build_url(context.base_url, path),
+            params=params,
+            json_body=json_body,
+            headers=request_headers,
+        )
+
+    def public_stream_request(
+        self,
+        method: str,
+        base_url: str,
+        path: str,
+        *,
+        params: JSONObject | None = None,
+        json_body: JSONValue = None,
+        headers: dict[str, str] | None = None,
+        qf_version: str | None = None,
+    ) -> list[str]:
+        request_headers = self._base_headers(None, None, qf_version=qf_version)
+        if headers:
+            request_headers.update({key: value for key, value in headers.items() if value is not None})
+        return self._stream_lines(
+            method,
+            self._build_url(base_url, path),
+            params=params,
+            json_body=json_body,
+            headers=request_headers,
+        )
+
     def describe_route(self, context: BackendRequestContext) -> JSONObject:
         qf_version, source = self._resolve_qf_version(context.qf_version)
         if context.qf_version is not None and context.qf_version_source:
@@ -430,6 +502,36 @@ class BackendClient:
         assert last_error is not None
         raise last_error
 
+    def _stream_lines(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: JSONObject | None,
+        json_body: JSONValue,
+        headers: dict[str, str],
+    ) -> list[str]:
+        try:
+            with self._client.stream(method.upper(), url, params=params, json=json_body, headers=headers) as response:
+                request_id = headers["Qf-Request-Id"]
+                if response.status_code >= 400:
+                    raw_bytes = response.read()
+                    payload: JSONValue
+                    try:
+                        payload = response.json()
+                    except ValueError:
+                        payload = raw_bytes.decode("utf-8", errors="replace")
+                    raise QingflowApiError(
+                        category="http",
+                        message=self._extract_message(payload) or f"HTTP {response.status_code}",
+                        backend_code=self._extract_code(payload),
+                        request_id=request_id,
+                        http_status=response.status_code,
+                    )
+                return [line for line in response.iter_lines()]
+        except httpx.RequestError as exc:
+            raise QingflowApiError(category="network", message=str(exc), request_id=headers["Qf-Request-Id"])
+
     def _parse_response(self, response: httpx.Response, request_id: str, *, unwrap: bool) -> JSONValue:
         payload: JSONValue
         try: