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

package/src/qingflow_mcp/builder_facade/service.py

@@ -379,6 +379,61 @@ class AiBuilderFacade:
             "tag_icon": tag_icon,
         }
 
+    def solution_install(
+        self,
+        *,
+        profile: str,
+        solution_key: str,
+        being_copy_data: bool = True,
+        solution_source: str = "solutionDetail",
+    ) -> JSONObject:
+        requested_solution_key = str(solution_key or "").strip()
+        requested_solution_source = str(solution_source or "").strip() or "solutionDetail"
+        normalized_args = {
+            "solution_key": requested_solution_key,
+            "being_copy_data": bool(being_copy_data),
+            "solution_source": requested_solution_source,
+        }
+        if not requested_solution_key:
+            return _failed(
+                "SOLUTION_KEY_REQUIRED",
+                "solution_key is required",
+                normalized_args=normalized_args,
+                suggested_next_call=None,
+            )
+        try:
+            created = self.apps.app_create(
+                profile=profile,
+                payload={
+                    "solutionKey": requested_solution_key,
+                    "beingCopyData": bool(being_copy_data),
+                    "solutionSource": requested_solution_source,
+                },
+            )
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "SOLUTION_INSTALL_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"solution_key": requested_solution_key},
+                suggested_next_call={"tool_name": "solution_install", "arguments": {"profile": profile, **normalized_args}},
+            )
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "installed solution",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": created.get("request_id"),
+            "suggested_next_call": None,
+            "noop": False,
+            "verification": {},
+        }
+
     def package_list(self, *, profile: str, trial_status: str = "all") -> JSONObject:
         listed = self.packages.package_list(profile=profile, trial_status=trial_status, include_raw=False)
         return {
@@ -2088,6 +2143,280 @@ class AiBuilderFacade:
             result["message"] = "read app field config"
         return result
 
+    def app_repair_code_blocks(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        field: str | None = None,
+        apply: bool = False,
+    ) -> JSONObject:
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "FIELDS_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key, "field": field, "apply": apply},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        parsed_fields = cast(list[dict[str, Any]], state["parsed"].get("fields") or [])
+        field_lookup = _build_public_field_lookup(parsed_fields)
+        selected_fields: list[dict[str, Any]]
+        requested_selector = str(field or "").strip()
+        if requested_selector:
+            try:
+                selected_field = _resolve_public_field(requested_selector, field_lookup=field_lookup)
+            except ValueError:
+                return _failed(
+                    "FIELD_NOT_FOUND",
+                    "field selector did not match any existing field",
+                    normalized_args={"app_key": app_key, "field": requested_selector, "apply": apply},
+                    details={"app_key": app_key, "field": requested_selector},
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            if str(selected_field.get("type") or "") != FieldType.code_block.value:
+                return _failed(
+                    "CODE_BLOCK_FIELD_REQUIRED",
+                    "selected field is not a code_block field",
+                    normalized_args={"app_key": app_key, "field": requested_selector, "apply": apply},
+                    details={"app_key": app_key, "field": requested_selector, "field_type": selected_field.get("type")},
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            selected_fields = [selected_field]
+        else:
+            selected_fields = [field_item for field_item in parsed_fields if str(field_item.get("type") or "") == FieldType.code_block.value]
+        plans: list[dict[str, Any]] = []
+        update_fields: list[FieldUpdatePatch] = []
+        applied_fields: list[str] = []
+        for code_block_field in selected_fields:
+            field_name = _code_block_field_display_name(code_block_field)
+            normalized_binding = _normalize_code_block_binding(code_block_field.get("code_block_binding"))
+            normalized_config = _normalize_code_block_config(code_block_field.get("code_block_config") or code_block_field.get("config") or {}) or None
+            raw_binding = code_block_field.get("code_block_binding") if isinstance(code_block_field.get("code_block_binding"), dict) else None
+            preserved_output_targets = [
+                str((output.get("target_field") or {}).get("name") or "").strip()
+                for output in cast(list[dict[str, Any]], (normalized_binding or {}).get("outputs") or [])
+                if isinstance(output.get("target_field"), dict) and str((output.get("target_field") or {}).get("name") or "").strip()
+            ]
+            detected_issues: list[str] = []
+            warnings: list[dict[str, Any]] = []
+            normalized_code_preview: str | None = None
+            normalized_binding_code = None
+            normalized_config_code = None
+            if normalized_binding is not None:
+                raw_code = str(normalized_binding.get("code") or "")
+                normalized_binding_code = _normalize_code_block_output_assignment(raw_code)
+                if normalized_binding_code != raw_code:
+                    detected_issues.append("CONST_OR_LET_QF_OUTPUT_ASSIGNMENT")
+                    normalized_code_preview = normalized_binding_code
+            if normalized_config is not None:
+                raw_code_content = str(normalized_config.get("code_content") or "")
+                normalized_config_code = _normalize_code_block_output_assignment(raw_code_content)
+                if normalized_code_preview is None and normalized_config_code != raw_code_content:
+                    normalized_code_preview = normalized_config_code
+            try:
+                _validate_code_block_alias_config(
+                    field_name=field_name,
+                    raw_binding=raw_binding,
+                    normalized_config=normalized_config,
+                )
+            except _CodeBlockValidationError as error:
+                detected_issues.append(error.error_code)
+                warnings.append(_warning(error.error_code, error.message))
+            has_outputs = bool((normalized_binding or {}).get("outputs")) or bool((normalized_config or {}).get("result_alias_path"))
+            effective_code = ""
+            if normalized_binding is not None:
+                effective_code = str(normalized_binding_code if normalized_binding_code is not None else normalized_binding.get("code") or "")
+            elif normalized_config is not None:
+                code_content = str(normalized_config_code if normalized_config_code is not None else normalized_config.get("code_content") or "")
+                effective_code = _strip_code_block_generated_input_prelude(code_content)
+            if has_outputs and not _code_block_has_effective_output_assignment(effective_code):
+                detected_issues.append("CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING")
+                warnings.append(
+                    _warning(
+                        "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING",
+                        "configured outputs require qf_output assignment before runtime writeback can succeed",
+                    )
+                )
+            target_relation_default_verified = True
+            binding_has_target_bindings = False
+            for output in cast(list[dict[str, Any]], (normalized_binding or {}).get("outputs") or []):
+                target_payload = output.get("target_field")
+                if not isinstance(target_payload, dict):
+                    continue
+                if any(target_payload.values()):
+                    binding_has_target_bindings = True
+                try:
+                    target_field = _resolve_field_selector_with_uniqueness(
+                        fields=parsed_fields,
+                        selector_payload=target_payload,
+                        location="repair.target_field",
+                    )
+                except ValueError:
+                    target_relation_default_verified = False
+                    detected_issues.append("CODE_BLOCK_TARGET_DEFAULT_INVALID")
+                    warnings.append(_warning("CODE_BLOCK_TARGET_DEFAULT_INVALID", "bound output target could not be resolved during repair scan"))
+                    break
+                if _coerce_any_int(target_field.get("default_type")) == DEFAULT_TYPE_RELATION:
+                    continue
+                target_relation_default_verified = False
+                detected_issues.append("CODE_BLOCK_TARGET_DEFAULT_INVALID")
+                warnings.append(
+                    _warning(
+                        "CODE_BLOCK_TARGET_DEFAULT_INVALID",
+                        "bound output target is not stored as relation default and should be rebuilt through repair",
+                        target_field_name=_code_block_field_display_name(target_field),
+                    )
+                )
+            alias_issue_detected = "CODE_BLOCK_ALIAS_REQUIRED" in detected_issues
+            assignment_missing_detected = "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING" in detected_issues
+            can_auto_repair = not alias_issue_detected and not assignment_missing_detected
+            repair_mode = "none"
+            patch_payload: dict[str, Any] | None = None
+            safe_auto_fix = False
+            if can_auto_repair and normalized_binding is not None and binding_has_target_bindings and (
+                (normalized_binding_code is not None and normalized_binding_code != str(normalized_binding.get("code") or ""))
+                or not target_relation_default_verified
+            ):
+                patch_payload = {
+                    "selector": _field_selector_payload_for_field(code_block_field),
+                    "set": {
+                        "code_block_binding": _public_code_block_binding_payload(
+                            {**normalized_binding, "code": normalized_binding_code if normalized_binding_code is not None else str(normalized_binding.get("code") or "")}
+                        )
+                    },
+                }
+                repair_mode = "binding"
+                safe_auto_fix = True
+            elif (
+                can_auto_repair
+                and normalized_config is not None
+                and normalized_config_code is not None
+                and normalized_config_code != str(normalized_config.get("code_content") or "")
+            ):
+                patch_payload = {
+                    "selector": _field_selector_payload_for_field(code_block_field),
+                    "set": {"code_block_config": {**normalized_config, "code_content": normalized_config_code}},
+                }
+                repair_mode = "config"
+                safe_auto_fix = True
+            if not detected_issues:
+                detected_issues.append("NO_REPAIR_NEEDED")
+            plan = {
+                "field_name": field_name,
+                "field_id": str(code_block_field.get("field_id") or "").strip() or None,
+                "que_id": _coerce_positive_int(code_block_field.get("que_id")),
+                "detected_issues": sorted(set(detected_issues)),
+                "normalized_code_preview": normalized_code_preview,
+                "would_update": bool(patch_payload and safe_auto_fix),
+                "applied": False,
+                "repair_mode": repair_mode,
+                "preserved_output_targets": preserved_output_targets,
+                "warnings": warnings,
+            }
+            if patch_payload and safe_auto_fix:
+                update_fields.append(FieldUpdatePatch.model_validate(patch_payload))
+            plans.append(plan)
+        if not apply:
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "planned code block repair",
+                "normalized_args": {"app_key": app_key, "field": requested_selector or None, "apply": False},
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": not bool(update_fields),
+                "warnings": [],
+                "verification": {
+                    "app_exists": True,
+                    "code_block_fields_scanned": len(plans),
+                    "would_update": bool(update_fields),
+                },
+                "verified": True,
+                "app_key": app_key,
+                "apply": False,
+                "repair_plan": plans,
+                "would_update_fields": [plan["field_name"] for plan in plans if plan["would_update"]],
+            }
+        if not update_fields:
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "no safe code block repairs were required",
+                "normalized_args": {"app_key": app_key, "field": requested_selector or None, "apply": True},
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": True,
+                "warnings": [],
+                "verification": {
+                    "app_exists": True,
+                    "code_block_fields_scanned": len(plans),
+                    "would_update": False,
+                    "applied": False,
+                },
+                "verified": True,
+                "app_key": app_key,
+                "apply": True,
+                "repair_plan": plans,
+                "applied_fields": [],
+            }
+        apply_result = self.app_schema_apply(
+            profile=profile,
+            app_key=app_key,
+            package_tag_id=None,
+            app_name="",
+            publish=True,
+            add_fields=[],
+            update_fields=update_fields,
+            remove_fields=[],
+        )
+        if apply_result.get("status") == "failed":
+            return apply_result
+        try:
+            reread = self._load_base_schema_state(profile=profile, app_key=app_key)
+            verified_fields = cast(list[dict[str, Any]], reread["parsed"].get("fields") or [])
+            verified_lookup = _build_public_field_lookup(verified_fields)
+            for plan in plans:
+                selector = plan["field_id"] or plan["field_name"] or plan["que_id"]
+                if selector is None:
+                    continue
+                try:
+                    verified_field = _resolve_public_field(selector, field_lookup=verified_lookup)
+                except ValueError:
+                    continue
+                verified_binding = _normalize_code_block_binding(verified_field.get("code_block_binding"))
+                verified_config = _normalize_code_block_config(verified_field.get("code_block_config") or verified_field.get("config") or {}) or {}
+                verified_code = str((verified_binding or {}).get("code") or "")
+                verified_content = str(verified_config.get("code_content") or "")
+                if "const qf_output =" not in verified_code and "let qf_output =" not in verified_code and "const qf_output =" not in verified_content and "let qf_output =" not in verified_content:
+                    if plan["would_update"]:
+                        plan["applied"] = True
+                        applied_fields.append(plan["field_name"])
+        except (QingflowApiError, RuntimeError):
+            pass
+        apply_result["message"] = "repaired code block fields"
+        apply_result["apply"] = True
+        apply_result["repair_plan"] = plans
+        apply_result["applied_fields"] = applied_fields
+        apply_result["verification"] = {
+            **(apply_result.get("verification") if isinstance(apply_result.get("verification"), dict) else {}),
+            "code_block_fields_scanned": len(plans),
+            "would_update": bool(update_fields),
+            "applied": bool(applied_fields),
+        }
+        return apply_result
+
     def app_get_layout(self, *, profile: str, app_key: str) -> JSONObject:
         result = self.app_read_layout_summary(profile=profile, app_key=app_key)
         if result.get("status") == "success":
@@ -3338,18 +3667,33 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
 
+        normalized_code_block_fields: list[str] = []
         try:
+            current_fields, normalized_code_block_fields = _normalize_and_validate_code_block_fields_for_write(fields=current_fields)
             current_fields, compiled_question_relations = _compile_code_block_binding_fields(
                 fields=current_fields,
                 current_schema=schema_result,
             )
+            _ensure_code_block_targets_compiled_as_relation_defaults(fields=current_fields)
+        except _CodeBlockValidationError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details={"app_key": target.app_key, **error.details},
+                suggested_next_call=_code_block_repair_suggested_next_call(
+                    profile=profile,
+                    app_key=target.app_key,
+                    field_name=str(error.details.get("field_name") or "").strip() or None,
+                ),
+            )
         except ValueError as error:
             return _failed(
                 "CODE_BLOCK_BINDING_INVALID",
                 str(error),
                 normalized_args=normalized_args,
                 details={"app_key": target.app_key},
-                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                suggested_next_call=_code_block_repair_suggested_next_call(profile=profile, app_key=target.app_key),
             )
 
         q_linker_schema_context = deepcopy(schema_result)
@@ -3375,8 +3719,19 @@ class AiBuilderFacade:
             if not relation_limit_verified
             else []
         )
+        code_block_normalization_warnings = (
+            [
+                _warning(
+                    "CODE_BLOCK_OUTPUT_ASSIGNMENT_NORMALIZED",
+                    "normalized code block qf_output assignment before schema write",
+                    field_names=normalized_code_block_fields,
+                )
+            ]
+            if normalized_code_block_fields
+            else []
+        )
 
-        if not added and not updated and not removed and not bool(resolved.get("created")):
+        if not added and not updated and not removed and not normalized_code_block_fields and not bool(resolved.get("created")):
             tag_ids_after = _coerce_int_list((self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}).get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
             response = {
@@ -3391,7 +3746,7 @@ class AiBuilderFacade:
                 "request_id": None,
                 "suggested_next_call": None if package_attached is not False else {"tool_name": "package_attach_app", "arguments": {"profile": profile, "tag_id": package_tag_id, "app_key": target.app_key}},
                 "noop": not bool(visual_result.get("updated")),
-                "warnings": relation_warnings,
+                "warnings": relation_warnings + code_block_normalization_warnings,
                 "verification": {
                     "fields_verified": True,
                     "relation_field_limit_verified": relation_limit_verified,
@@ -3407,6 +3762,9 @@ class AiBuilderFacade:
                 "package_attached": package_attached,
             }
             response["details"]["relation_field_count"] = relation_field_count
+            if normalized_code_block_fields:
+                response["normalized_code_block_output_assignment"] = True
+                response["normalized_code_block_fields"] = normalized_code_block_fields
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
@@ -3473,16 +3831,30 @@ class AiBuilderFacade:
                 rebound_layout = cast(dict[str, Any], rebound_parsed.get("layout") or {"root_rows": [], "sections": []})
                 _overlay_code_block_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
                 _overlay_q_linker_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
+                rebound_fields, _normalized_rebound_code_blocks = _normalize_and_validate_code_block_fields_for_write(fields=rebound_fields)
                 rebound_fields, compiled_question_relations = _compile_code_block_binding_fields(
                     fields=rebound_fields,
                     current_schema=rebound_schema,
                 )
+                _ensure_code_block_targets_compiled_as_relation_defaults(fields=rebound_fields)
                 rebound_q_linker_schema = deepcopy(rebound_schema)
                 rebound_q_linker_schema["questionRelations"] = deepcopy(compiled_question_relations)
                 rebound_fields, compiled_question_relations = _compile_q_linker_binding_fields(
                     fields=rebound_fields,
                     current_schema=rebound_q_linker_schema,
                 )
+            except _CodeBlockValidationError as error:
+                return _failed(
+                    error.error_code,
+                    error.message,
+                    normalized_args=normalized_args,
+                    details={"app_key": target.app_key, **error.details},
+                    suggested_next_call=_code_block_repair_suggested_next_call(
+                        profile=profile,
+                        app_key=target.app_key,
+                        field_name=str(error.details.get("field_name") or "").strip() or None,
+                    ),
+                )
             except ValueError as error:
                 return _failed(
                     "Q_LINKER_BINDING_INVALID" if "q_linker" in str(error) else "CODE_BLOCK_BINDING_INVALID",
@@ -3544,7 +3916,7 @@ class AiBuilderFacade:
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "warnings": relation_warnings,
+            "warnings": relation_warnings + code_block_normalization_warnings,
             "verification": {
                 "fields_verified": False,
                 "package_attached": None,
@@ -3565,6 +3937,9 @@ class AiBuilderFacade:
             "package_attached": None,
         }
         response["details"]["relation_field_count"] = relation_field_count
+        if normalized_code_block_fields:
+            response["normalized_code_block_output_assignment"] = True
+            response["normalized_code_block_fields"] = normalized_code_block_fields
         if schema_readback_delayed:
             response["verification"]["schema_readback_delayed"] = True
         response = _apply_permission_outcomes(response, relation_permission_outcome)
@@ -8785,6 +9160,7 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
         "q_linker_binding": q_linker_binding,
         "code_block_config": code_block_config,
         "code_block_binding": code_block_binding,
+        "_explicit_code_block_binding": code_block_binding is not None,
         "config": deepcopy(remote_lookup_config) if remote_lookup_config is not None else (deepcopy(code_block_config) if code_block_config is not None else {}),
         "auto_trigger": patch.auto_trigger,
         "custom_button_text_enabled": patch.custom_button_text_enabled,
@@ -9011,6 +9387,7 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["config"] = deepcopy(payload["code_block_config"])
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
+        field["_explicit_code_block_binding"] = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
     if "custom_button_text_enabled" in payload:
@@ -9087,7 +9464,225 @@ def _strip_code_block_generated_input_prelude(code_content: str) -> str:
 
 
 def _normalize_code_block_output_assignment(code_content: str) -> str:
-    return re.sub(r"(?m)^(\s*)(?:const|let)\s+qf_output\s*=", r"\1qf_output =", code_content)
+    return re.sub(r"(?<![A-Za-z0-9_$])(?:const|let)\s+qf_output\s*=", "qf_output =", code_content)
+
+
+@dataclass
+class _CodeBlockValidationError(ValueError):
+    error_code: str
+    message: str
+    details: JSONObject = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        return self.message
+
+
+def _code_block_has_effective_output_assignment(code_content: str) -> bool:
+    return bool(re.search(r"(?<![A-Za-z0-9_$])qf_output\s*=", str(code_content or "")))
+
+
+def _field_selector_payload_for_field(field: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    field_id = str(field.get("field_id") or "").strip()
+    que_id = _coerce_positive_int(field.get("que_id"))
+    name = str(field.get("name") or "").strip()
+    if field_id:
+        payload["field_id"] = field_id
+    elif que_id is not None:
+        payload["que_id"] = que_id
+    elif name:
+        payload["name"] = name
+    return payload
+
+
+def _field_selector_payload_for_selector(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        payload = {
+            "field_id": str(value.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(value.get("que_id")),
+            "name": str(value.get("name") or "").strip() or None,
+        }
+        return {key: item for key, item in payload.items() if item is not None}
+    if isinstance(value, str) and value.strip():
+        return {"name": value.strip()}
+    return {}
+
+
+def _code_block_field_display_name(field: dict[str, Any]) -> str:
+    name = str(field.get("name") or "").strip()
+    if name:
+        return name
+    field_id = str(field.get("field_id") or "").strip()
+    if field_id:
+        return field_id
+    que_id = _coerce_positive_int(field.get("que_id"))
+    if que_id is not None:
+        return str(que_id)
+    return "未命名代码块"
+
+
+def _public_code_block_binding_payload(binding: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "inputs": [
+            {
+                "field": _field_selector_payload_for_selector(input_item.get("field")),
+                "var": input_item.get("var"),
+            }
+            for input_item in cast(list[dict[str, Any]], binding.get("inputs") or [])
+            if _field_selector_payload_for_selector(input_item.get("field"))
+        ],
+        "code": str(binding.get("code") or ""),
+        "auto_trigger": binding.get("auto_trigger"),
+        "custom_button_text_enabled": binding.get("custom_button_text_enabled"),
+        "custom_button_text": binding.get("custom_button_text"),
+        "outputs": [
+            {
+                "alias": str(output.get("alias") or "").strip(),
+                "path": str(output.get("path") or "").strip(),
+                "target_field": _field_selector_payload_for_selector(output.get("target_field")),
+            }
+            for output in cast(list[dict[str, Any]], binding.get("outputs") or [])
+            if str(output.get("alias") or "").strip()
+            and str(output.get("path") or "").strip()
+            and _field_selector_payload_for_selector(output.get("target_field"))
+        ],
+    }
+
+
+def _raw_field_selector_present(value: Any) -> bool:
+    if isinstance(value, str):
+        return bool(value.strip())
+    if not isinstance(value, dict):
+        return False
+    return bool(
+        str(value.get("field_id") or "").strip()
+        or _coerce_positive_int(value.get("que_id"))
+        or str(value.get("name") or value.get("title") or value.get("label") or "").strip()
+    )
+
+
+def _validate_code_block_alias_config(
+    *,
+    field_name: str,
+    raw_binding: dict[str, Any] | None,
+    normalized_config: dict[str, Any] | None,
+) -> None:
+    raw_outputs = raw_binding.get("outputs") if isinstance(raw_binding, dict) and isinstance(raw_binding.get("outputs"), list) else []
+    for index, raw_output in enumerate(cast(list[Any], raw_outputs)):
+        if not isinstance(raw_output, dict):
+            continue
+        raw_target = raw_output.get("target_field", raw_output.get("targetField"))
+        if not _raw_field_selector_present(raw_target):
+            continue
+        alias = str(raw_output.get("alias", raw_output.get("alias_name", raw_output.get("aliasName", ""))) or "").strip()
+        path = str(raw_output.get("path", raw_output.get("alias_path", raw_output.get("aliasPath", ""))) or "").strip()
+        if alias and path:
+            continue
+        raise _CodeBlockValidationError(
+            "CODE_BLOCK_ALIAS_REQUIRED",
+            f"code_block field '{field_name}' requires non-empty alias and path for output target binding",
+            details={"field_name": field_name, "output_index": index},
+        )
+    normalized_aliases = cast(list[dict[str, Any]], (normalized_config or {}).get("result_alias_path") or [])
+    for index, alias_item in enumerate(normalized_aliases):
+        alias_name = str(alias_item.get("alias_name") or "").strip()
+        alias_path = str(alias_item.get("alias_path") or "").strip()
+        if alias_name and alias_path:
+            continue
+        raise _CodeBlockValidationError(
+            "CODE_BLOCK_ALIAS_REQUIRED",
+            f"code_block field '{field_name}' contains an empty output alias configuration",
+            details={"field_name": field_name, "alias_index": index},
+        )
+
+
+def _normalize_and_validate_code_block_fields_for_write(
+    *,
+    fields: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[str]]:
+    next_fields = deepcopy(fields)
+    normalized_fields: list[str] = []
+    for field in next_fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        field_name = _code_block_field_display_name(field)
+        raw_binding = field.get("code_block_binding") if isinstance(field.get("code_block_binding"), dict) else None
+        binding = _normalize_code_block_binding(raw_binding)
+        current_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or None
+        _validate_code_block_alias_config(field_name=field_name, raw_binding=raw_binding, normalized_config=current_config)
+        normalized = False
+        if binding is not None:
+            raw_code = str(binding.get("code") or "")
+            normalized_code = _normalize_code_block_output_assignment(raw_code)
+            if normalized_code != raw_code:
+                normalized = True
+            binding["code"] = normalized_code
+            field["code_block_binding"] = binding
+        if current_config is not None:
+            raw_code_content = str(current_config.get("code_content") or "")
+            normalized_code_content = _normalize_code_block_output_assignment(raw_code_content)
+            if normalized_code_content != raw_code_content:
+                normalized = True
+            current_config["code_content"] = normalized_code_content
+            field["code_block_config"] = current_config
+            field["config"] = deepcopy(current_config)
+        conflicting_binding_and_config = False
+        if binding is not None and current_config is not None:
+            current_config_code = str(current_config.get("code_content") or "")
+            compiled_body = _strip_code_block_generated_input_prelude(current_config_code)
+            if current_config_code.strip() and compiled_body != str(binding.get("code") or ""):
+                conflicting_binding_and_config = True
+        has_outputs = bool((binding or {}).get("outputs")) or bool((current_config or {}).get("result_alias_path"))
+        effective_code = ""
+        if binding is not None:
+            effective_code = str(binding.get("code") or "")
+        elif current_config is not None:
+            effective_code = _strip_code_block_generated_input_prelude(str(current_config.get("code_content") or ""))
+        if has_outputs and not conflicting_binding_and_config and not _code_block_has_effective_output_assignment(effective_code):
+            raise _CodeBlockValidationError(
+                "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING",
+                f"code_block field '{field_name}' must assign to qf_output when outputs are configured",
+                details={"field_name": field_name},
+            )
+        if normalized:
+            normalized_fields.append(field_name)
+    return next_fields, sorted(set(normalized_fields))
+
+
+def _ensure_code_block_targets_compiled_as_relation_defaults(*, fields: list[dict[str, Any]]) -> None:
+    for field in fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        field_name = _code_block_field_display_name(field)
+        binding = _normalize_code_block_binding(field.get("code_block_binding"))
+        if binding is None:
+            continue
+        for output_index, output in enumerate(cast(list[dict[str, Any]], binding.get("outputs") or [])):
+            target_payload = output.get("target_field")
+            if not isinstance(target_payload, dict):
+                continue
+            target_field = _resolve_field_selector_with_uniqueness(
+                fields=fields,
+                selector_payload=target_payload,
+                location=f"code_block_binding.outputs[{output_index}].target_field",
+            )
+            if _coerce_any_int(target_field.get("default_type")) == DEFAULT_TYPE_RELATION:
+                continue
+            raise _CodeBlockValidationError(
+                "CODE_BLOCK_TARGET_DEFAULT_INVALID",
+                f"code_block field '{field_name}' output target '{_code_block_field_display_name(target_field)}' is not compiled as relation default",
+                details={
+                    "field_name": field_name,
+                    "target_field_name": _code_block_field_display_name(target_field),
+                },
+            )
+
+
+def _code_block_repair_suggested_next_call(*, profile: str, app_key: str, field_name: str | None = None) -> JSONObject:
+    arguments: JSONObject = {"profile": profile, "app_key": app_key}
+    if field_name:
+        arguments["field"] = field_name
+    return {"tool_name": "app_repair_code_blocks", "arguments": arguments}
 
 
 def _ensure_field_temp_ids(fields: list[dict[str, Any]]) -> None:
@@ -9122,12 +9717,21 @@ def _compile_code_block_binding_fields(
         binding = _normalize_code_block_binding(field.get("code_block_binding"))
         if binding is None:
             continue
+        explicit_binding = bool(field.get("_explicit_code_block_binding"))
+        binding_outputs = cast(list[dict[str, Any]], binding.get("outputs") or [])
+        binding_has_target_bindings = any(
+            isinstance(output.get("target_field"), dict) and any(cast(dict[str, Any], output.get("target_field") or {}).values())
+            for output in binding_outputs
+        )
         current_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
             "config_mode": 1,
             "code_content": "",
             "being_hide_on_form": False,
             "result_alias_path": [],
         }
+        if binding_outputs and not binding_has_target_bindings and not explicit_binding:
+            field["code_block_binding"] = None
+            continue
         low_level_code = _strip_code_block_generated_input_prelude(str(current_config.get("code_content") or ""))
         if str(current_config.get("code_content") or "").strip() and low_level_code != str(binding.get("code") or ""):
             raise ValueError(f"code_block field '{field.get('name')}' has conflicting code_block_config.code_content and code_block_binding.code")