@josephyan/qingflow-cli 0.2.0-beta.66 → 0.2.0-beta.68

package/src/qingflow_mcp/tools/code_block_tools.py

@@ -33,6 +33,27 @@ SUPPORTED_CODE_BLOCK_ROLES = {1, 2, 3, 5}
 
 
 class CodeBlockTools(RecordTools):
+    def _get_code_block_relation_schema(
+        self,
+        profile: str,
+        context,  # type: ignore[no-untyped-def]
+        app_key: str,
+        *,
+        force_refresh: bool,
+    ) -> JSONObject:
+        cache_key = (profile, app_key, "code_block_relation_form", 1)
+        if not force_refresh and cache_key in self._form_cache:
+            return self._form_cache[cache_key]
+        schema = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/form",
+            params={"type": 1},
+        )
+        normalized = schema if isinstance(schema, dict) else {}
+        self._form_cache[cache_key] = normalized
+        return normalized
+
     def register(self, mcp: FastMCP) -> None:
         super().register(mcp)
 
@@ -49,9 +70,10 @@ class CodeBlockTools(RecordTools):
 
         @mcp.tool(
             description=(
-                "Run a form code-block field against the current record data, then reuse Qingflow's existing "
-                "relation-calculation chain to compute bound outputs and write them back automatically. "
-                "Use record_code_block_schema_get first and choose an exact code-block field selector."
+                "Run a form code-block field against the current record data, parse alias results, and optionally "
+                "reuse Qingflow's existing relation-calculation chain to compute bound outputs and write them back. "
+                "Use record_code_block_schema_get first and choose an exact code-block field selector. "
+                "For safe debugging, pass apply_writeback=false to inspect parsed results without writing back."
             )
         )
         def record_code_block_run(
@@ -64,6 +86,7 @@ class CodeBlockTools(RecordTools):
             answers: list[JSONObject] | None = None,
             fields: JSONObject | None = None,
             manual: bool = True,
+            apply_writeback: bool = True,
             verify_writeback: bool = True,
             force_refresh_form: bool = False,
             output_profile: str = "normal",
@@ -78,6 +101,7 @@ class CodeBlockTools(RecordTools):
                 answers=answers or [],
                 fields=fields or {},
                 manual=manual,
+                apply_writeback=apply_writeback,
                 verify_writeback=verify_writeback,
                 force_refresh_form=force_refresh_form,
                 output_profile=output_profile,
@@ -95,7 +119,7 @@ class CodeBlockTools(RecordTools):
         normalized_output_profile = self._normalize_public_output_profile(output_profile)
 
         def runner(session_profile, context):
-            schema = self._get_form_schema(profile, context, app_key, force_refresh=False)
+            relation_schema = self._get_code_block_relation_schema(profile, context, app_key, force_refresh=False)
             index = self._get_applicant_top_level_field_index(profile, context, app_key, force_refresh=False)
             input_fields = [
                 self._ready_schema_field_payload(
@@ -113,7 +137,7 @@ class CodeBlockTools(RecordTools):
                 if field.que_type != CODE_BLOCK_QUE_TYPE:
                     continue
                 targets = _collect_code_block_relation_targets(
-                    _collect_question_relations(schema),
+                    _collect_question_relations(relation_schema),
                     code_block_que_id=field.que_id,
                 )
                 bound_output_fields = [
@@ -127,6 +151,7 @@ class CodeBlockTools(RecordTools):
                         "title": field.que_title,
                         "selector": field.que_title,
                         "bound_output_fields": bound_output_fields,
+                        "configured_aliases": _extract_code_block_configured_aliases(field),
                     }
                 )
             response: JSONObject = {
@@ -164,6 +189,7 @@ class CodeBlockTools(RecordTools):
         answers: list[JSONObject] | None = None,
         fields: JSONObject | None = None,
         manual: bool = True,
+        apply_writeback: bool = True,
         verify_writeback: bool = True,
         force_refresh_form: bool = False,
         output_profile: str = "normal",
@@ -178,7 +204,12 @@ class CodeBlockTools(RecordTools):
             raise_tool_error(QingflowApiError.config_error("code_block_field is required"))
 
         def runner(session_profile, context):
-            schema = self._get_form_schema(profile, context, app_key, force_refresh=force_refresh_form)
+            relation_schema = self._get_code_block_relation_schema(
+                profile,
+                context,
+                app_key,
+                force_refresh=force_refresh_form,
+            )
             index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form)
             code_block = self._resolve_field_selector(code_block_field, index, location="code_block_field")
             if code_block.que_type != CODE_BLOCK_QUE_TYPE:
@@ -233,8 +264,9 @@ class CodeBlockTools(RecordTools):
                 json_body=run_body,
             )
             alias_results = _normalize_code_block_alias_results(run_result)
+            configured_aliases = _extract_code_block_configured_aliases(code_block)
             relation_target_fields = _collect_code_block_relation_targets(
-                _collect_question_relations(schema),
+                _collect_question_relations(relation_schema),
                 code_block_que_id=code_block.que_id,
             )
             relation_errors: list[JSONObject] = []
@@ -277,7 +309,12 @@ class CodeBlockTools(RecordTools):
             writeback_applied = False
             status = "completed"
             ok = True
-            if relation_target_fields and calculated_answers:
+            if relation_errors:
+                status = "relation_failed"
+                ok = False
+            elif not apply_writeback:
+                status = "debug_completed"
+            elif relation_target_fields and calculated_answers:
                 write_body: JSONObject = {"role": role, "answers": calculated_answers}
                 if workflow_node_id is not None:
                     write_body["auditNodeId"] = workflow_node_id
@@ -305,9 +342,6 @@ class CodeBlockTools(RecordTools):
                     if not bool(verification.get("verified")):
                         status = "verification_failed"
                         ok = False
-            elif relation_errors:
-                status = "relation_failed"
-                ok = False
             else:
                 status = "no_writeback"
             response: JSONObject = {
@@ -325,9 +359,11 @@ class CodeBlockTools(RecordTools):
                     "role": role,
                     "workflow_node_id": workflow_node_id,
                     "manual": bool(manual),
+                    "apply_writeback": bool(apply_writeback),
                     "result_count": len(alias_results),
                 },
                 "outputs": {
+                    "configured_aliases": configured_aliases,
                     "alias_results": alias_results,
                     "alias_map": _build_alias_result_map(alias_results),
                 },
@@ -335,11 +371,14 @@ class CodeBlockTools(RecordTools):
                     "target_fields": relation_target_fields,
                     "result_item_count": len(relation_items),
                     "calculated_answer_count": len(calculated_answers),
+                    "calculated_answers_preview": calculated_answers,
                     "errors": relation_errors,
                 },
                 "writeback": {
+                    "enabled": bool(apply_writeback),
                     "attempted": writeback_attempted,
                     "applied": writeback_applied,
+                    "skipped_reason": "apply_writeback_disabled" if not apply_writeback else None,
                     "verify_writeback": verify_writeback,
                     "write_verified": bool(verification.get("verified")) if verification is not None else None,
                     "result": write_result,
@@ -606,6 +645,38 @@ def _normalize_code_block_alias_results(payload: JSONValue) -> list[JSONObject]:
     return results
 
 
+def _extract_code_block_configured_aliases(field: FormField) -> list[JSONObject]:
+    raw_config = field.raw.get("codeBlockConfig")
+    if not isinstance(raw_config, dict):
+        return []
+    raw_aliases = raw_config.get("resultAliasPath")
+    if not isinstance(raw_aliases, list):
+        return []
+    return [item for item in (_normalize_code_block_alias_item(alias) for alias in raw_aliases) if item is not None]
+
+
+def _normalize_code_block_alias_item(value: JSONValue) -> JSONObject | None:
+    if not isinstance(value, dict):
+        return None
+    alias_name = _normalize_optional_text(value.get("aliasName", value.get("alias_name")))
+    alias_path = _normalize_optional_text(value.get("aliasPath", value.get("alias_path")))
+    if alias_name is None and alias_path is None:
+        return None
+    raw_sub_alias = value.get("subAlias", value.get("sub_alias"))
+    sub_alias = (
+        [item for item in (_normalize_code_block_alias_item(entry) for entry in raw_sub_alias) if item is not None]
+        if isinstance(raw_sub_alias, list)
+        else []
+    )
+    return {
+        "alias_id": _coerce_count(value.get("aliasId", value.get("alias_id"))),
+        "alias_name": alias_name,
+        "alias_path": alias_path,
+        "alias_type": _coerce_count(value.get("aliasType", value.get("alias_type"))) or 1,
+        "sub_alias": sub_alias,
+    }
+
+
 def _build_alias_result_map(alias_results: list[JSONObject]) -> JSONObject:
     alias_map: JSONObject = {}
     for item in alias_results:
@@ -625,7 +696,11 @@ def _collect_code_block_relation_targets(question_relations: list[JSONObject], *
     for relation in question_relations:
         if _coerce_count(relation.get("relationType")) != CODE_BLOCK_RELATION_TYPE:
             continue
-        if _coerce_count(relation.get("qlinkerQueId")) != code_block_que_id:
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        relation_code_block_que_id = _coerce_count(relation.get("qlinkerQueId"))
+        if relation_code_block_que_id is None:
+            relation_code_block_que_id = _coerce_count(alias_config.get("queId"))
+        if relation_code_block_que_id != code_block_que_id:
             continue
         target_id = _coerce_count(
             relation.get("queId", relation.get("targetQueId", relation.get("displayedQueId")))
@@ -636,8 +711,10 @@ def _collect_code_block_relation_targets(question_relations: list[JSONObject], *
         targets.append(
             {
                 "que_id": target_id,
-                "alias_id": _coerce_count(relation.get("aliasId")),
-                "qlinker_que_id": _coerce_count(relation.get("qlinkerQueId")),
+                "alias_id": _coerce_count(relation.get("aliasId")) or _coerce_count(alias_config.get("aliasId")),
+                "alias_name": _normalize_optional_text(relation.get("qlinkerAlias"))
+                or _normalize_optional_text(alias_config.get("qlinkerAlias")),
+                "qlinker_que_id": relation_code_block_que_id,
             }
         )
     return targets

package/src/qingflow_mcp/tools/package_tools.py

@@ -200,6 +200,7 @@ class PackageTools(ToolBase):
         compact = {
             "tagId": result.get("tagId"),
             "tagName": result.get("tagName"),
+            "tagIcon": result.get("tagIcon") if result.get("tagIcon") is not None else permission_source.get("tagIcon"),
             "publishStatus": result.get("publishStatus") if result.get("publishStatus") is not None else permission_source.get("publishStatus"),
             "beingTrial": result.get("beingTrial"),
             "itemCount": len(tag_items),