@qingflow-tech/qingflow-app-builder-mcp 1.0.9 → 1.0.10

package/src/qingflow_mcp/tools/record_tools.py

@@ -3757,13 +3757,44 @@ class RecordTools(ToolBase):
         """执行内部辅助逻辑。"""
         summary = self._record_update_batch_summary(responses)
         batch_items = [self._record_update_batch_item_from_response(response, output_profile=output_profile) for response in responses]
+        public_items = [self._record_update_public_batch_item(item, index=index) for index, item in enumerate(batch_items)]
         status, ok, message = self._record_update_batch_envelope_status(summary=summary, dry_run=dry_run)
         first_response = responses[0] if responses else {}
+        applied_count = int(summary.get("applied_count") or 0)
+        ready_count = int(summary.get("ready_count") or 0)
+        verified_count = int(summary.get("verified_count") or 0)
+        field_level_verified_count = int(summary.get("field_level_verified_count") or 0)
+        confirmation_count = int(summary.get("confirmation_count") or 0)
+        blocked_count = int(summary.get("blocked_count") or 0)
+        failed_count = int(summary.get("failed_count") or 0)
+        write_executed = applied_count > 0
+        verification_status = "not_requested"
+        if write_executed:
+            verification_status = "verified" if verified_count == applied_count else "failed"
+        updated_record_ids = [
+            str(item.get("record_id"))
+            for item in public_items
+            if item.get("record_id") not in (None, "") and str(item.get("status") or "").lower() == "success"
+        ]
         return {
             "profile": first_response.get("profile", profile),
             "ws_id": first_response.get("ws_id"),
             "ok": ok,
             "status": status,
+            "mode": "batch",
+            "dry_run": dry_run,
+            "app_key": app_key,
+            "total": int(summary.get("total") or 0),
+            "succeeded": ready_count if dry_run else applied_count,
+            "failed": blocked_count + failed_count,
+            "needs_confirmation": confirmation_count,
+            "updated_record_ids": updated_record_ids,
+            "write_executed": write_executed,
+            "safe_to_retry": not write_executed,
+            "verification_status": verification_status,
+            "field_level_verified_count": field_level_verified_count,
+            "summary": summary,
+            "items": public_items,
             "request_route": first_response.get("request_route"),
             "warnings": [],
             "output_profile": output_profile,
@@ -3777,6 +3808,31 @@ class RecordTools(ToolBase):
             "message": message,
         }
 
+    def _record_update_public_batch_item(self, item: JSONObject, *, index: int) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        public = dict(item)
+        public.setdefault("index", index)
+        public.setdefault("row_number", index + 1)
+        resource = public.get("resource")
+        if isinstance(resource, dict):
+            record_id = resource.get("record_id")
+            apply_id = resource.get("apply_id")
+            if record_id not in (None, ""):
+                public["record_id"] = str(record_id)
+            if apply_id not in (None, ""):
+                public["apply_id"] = str(apply_id)
+        status = str(public.get("status") or "").lower()
+        verification = public.get("verification")
+        if isinstance(verification, dict):
+            if bool(verification.get("verified")):
+                public.setdefault("verification_status", "verified")
+            elif status == "success":
+                public.setdefault("verification_status", "failed")
+        public.setdefault("write_executed", status == "success")
+        public.setdefault("safe_to_retry", not bool(public.get("write_executed")))
+        public.setdefault("verification_status", "not_requested")
+        return public
+
     def _record_update_batch_summary(self, responses: list[JSONObject]) -> JSONObject:
         """执行内部辅助逻辑。"""
         summary: JSONObject = {
@@ -4702,6 +4758,11 @@ class RecordTools(ToolBase):
             delete_ids = [normalize_positive_id_int(record_id, field_name="record_id")]
         if not delete_ids:
             raise_tool_error(QingflowApiError.config_error("record_id or record_ids is required"))
+        seen_delete_ids: set[int] = set()
+        for item in delete_ids:
+            if item in seen_delete_ids:
+                raise_tool_error(QingflowApiError.config_error(f"duplicate record id in delete payload: {stringify_backend_id(item)}"))
+            seen_delete_ids.add(item)
         normalized_payload = {
             "operation": "delete",
             "record_id": stringify_backend_id(record_id) if record_id is not None else None,
@@ -4709,16 +4770,134 @@ class RecordTools(ToolBase):
             "answers": [],
             "submit_type": 1,
         }
-        raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=delete_ids)
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="delete",
+        return self._record_delete_public_batch(
+            profile=profile,
+            app_key=app_key,
+            delete_ids=delete_ids,
             normalized_payload=normalized_payload,
             output_profile=normalized_output_profile,
-            human_review=True,
-            preflight=None,
         )
 
+    def _record_delete_public_batch(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        delete_ids: list[int],
+        normalized_payload: JSONObject,
+        output_profile: str,
+    ) -> JSONObject:
+        items: list[JSONObject] = []
+        request_route: JSONObject | None = None
+        ws_id: object = None
+        for index, delete_id in enumerate(delete_ids):
+            record_id_text = stringify_backend_id(delete_id)
+            try:
+                raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=[delete_id])
+                request_route = cast(JSONObject, raw_apply.get("request_route")) if isinstance(raw_apply.get("request_route"), dict) else request_route
+                ws_id = raw_apply.get("ws_id", ws_id)
+                single_payload = {
+                    "operation": "delete",
+                    "record_id": record_id_text,
+                    "record_ids": [record_id_text],
+                    "answers": [],
+                    "submit_type": 1,
+                }
+                single_response = self._record_write_apply_response(
+                    raw_apply,
+                    operation="delete",
+                    normalized_payload=single_payload,
+                    output_profile=output_profile,
+                    human_review=True,
+                    preflight=None,
+                )
+                item_status = str(single_response.get("status") or "success")
+                item: JSONObject = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": item_status,
+                    "write_executed": bool(single_response.get("write_executed")),
+                    "verification_status": single_response.get("verification_status", "not_requested"),
+                    "safe_to_retry": bool(single_response.get("safe_to_retry", False)),
+                }
+                if item_status != "success":
+                    item["error"] = (single_response.get("data") or {}).get("error") if isinstance(single_response.get("data"), dict) else None
+                items.append(item)
+            except (QingflowApiError, RuntimeError) as exc:
+                error_response = self._record_write_exception_response(
+                    exc,
+                    operation="delete",
+                    profile=profile,
+                    app_key=app_key,
+                    record_id=record_id_text,
+                    output_profile=output_profile,
+                    human_review=True,
+                    write_executed=False,
+                )
+                request_route = cast(JSONObject, error_response.get("request_route")) if isinstance(error_response.get("request_route"), dict) else request_route
+                item = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": "failed",
+                    "write_executed": False,
+                    "verification_status": "not_requested",
+                    "safe_to_retry": True,
+                    "error": (error_response.get("data") or {}).get("error") if isinstance(error_response.get("data"), dict) else {"message": str(exc)},
+                }
+                items.append(item)
+        deleted_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") == "success"
+        ]
+        failed_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") != "success"
+        ]
+        total = len(items)
+        succeeded = len(deleted_ids)
+        failed = len(failed_ids)
+        if succeeded and failed:
+            status = "partial_success"
+            ok = False
+        elif succeeded:
+            status = "success"
+            ok = True
+        else:
+            status = "failed"
+            ok = False
+        write_executed = any(bool(item.get("write_executed")) for item in items)
+        return {
+            "profile": profile,
+            "ws_id": ws_id,
+            "ok": ok,
+            "status": status,
+            "mode": "batch",
+            "total": total,
+            "succeeded": succeeded,
+            "failed": failed,
+            "deleted_ids": deleted_ids,
+            "failed_ids": failed_ids,
+            "write_executed": write_executed,
+            "verification_status": "not_requested",
+            "safe_to_retry": False if write_executed else True,
+            "request_route": request_route,
+            "warnings": [],
+            "output_profile": output_profile,
+            "items": items,
+            "data": {
+                "action": {"operation": "delete", "executed": write_executed},
+                "resource": {"type": "record", "app_key": app_key, "record_id": None, "record_ids": [stringify_backend_id(item) for item in delete_ids]},
+                "normalized_payload": normalized_payload,
+                "deleted_ids": deleted_ids,
+                "failed_ids": failed_ids,
+                "items": items,
+            },
+        }
+
     @tool_cn_name("写入记录")
     def record_write(
         self,
@@ -7277,6 +7456,7 @@ class RecordTools(ToolBase):
                 field_index_override=index,
             )
         except RecordInputError as error:
+            normalized_answers = list(lookup_resolution.normalized_answers)
             invalid_fields.append(
                 {
                     "location": _stringify_json(error.details.get("location") if error.details else None),
@@ -18780,6 +18960,15 @@ def _write_format_for_field(field: FormField) -> JSONObject:
         return _write_support_payload(support_level="full", kind="boolean_label", examples=["是", "否"])
     if field.que_type in DATE_QUE_TYPES:
         return _write_support_payload(support_level="full", kind="date_string", examples=["2026-03-13 10:00:00"])
+    if field.que_type == 8:
+        allow_decimal = bool((field.raw or {}).get("canDecimal"))
+        payload = _write_support_payload(
+            support_level="full",
+            kind="amount_number",
+            examples=[100.5 if allow_decimal else 100],
+        )
+        payload["allow_decimal"] = allow_decimal
+        return payload
     return _write_support_payload(support_level="full", kind="scalar_text")
 
 
@@ -18805,6 +18994,11 @@ def _ready_schema_format_hint(kind: str, write_format: JSONObject) -> str:
     if kind == "date":
         return "推荐传 'YYYY-MM-DD HH:MM:SS'；只有日期时可传 'YYYY-MM-DD'。"
     if kind == "number":
+        write_kind = _normalize_optional_text(write_format.get("kind"))
+        if write_kind == "amount_number":
+            if bool(write_format.get("allow_decimal")):
+                return "传数字或数字字符串，支持小数。"
+            return "传整数或整数字符串；该字段后端不接受小数。"
         return "传数字或数字字符串。"
     if kind == "unsupported":
         reason = _normalize_optional_text(write_format.get("reason"))