@josephyan/qingflow-cli 0.2.0-beta.72 → 0.2.0-beta.74

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.72",
+  "version": "0.2.0-beta.74",
   "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 = "0.2.0b72"
+version = "0.2.0b74"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

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:

package/src/qingflow_mcp/builder_facade/models.py

@@ -187,7 +187,8 @@ class FlowConditionRulePatch(StrictModel):
             return value
         payload = dict(value)
         if "value" in payload and "values" not in payload:
-            payload["values"] = [payload.pop("value")]
+            raw_value = payload.pop("value")
+            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
         raw_operator = payload.get("operator", payload.get("op"))
         if isinstance(raw_operator, str):
             normalized = raw_operator.strip().lower()
@@ -238,7 +239,8 @@ class ViewFilterRulePatch(StrictModel):
             return value
         payload = dict(value)
         if "value" in payload and "values" not in payload:
-            payload["values"] = [payload.pop("value")]
+            raw_value = payload.pop("value")
+            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
         raw_operator = payload.get("operator", payload.get("op"))
         if isinstance(raw_operator, str):
             normalized = raw_operator.strip().lower()
@@ -1092,7 +1094,8 @@ class ChartFilterRulePatch(StrictModel):
             return value
         payload = dict(value)
         if "value" in payload and "values" not in payload:
-            payload["values"] = [payload.pop("value")]
+            raw_value = payload.pop("value")
+            payload["values"] = list(raw_value) if isinstance(raw_value, list) else [raw_value]
         raw_operator = payload.get("operator", payload.get("op"))
         if isinstance(raw_operator, str):
             normalized = raw_operator.strip().lower()