implemented get_form tool

tools/templates_tools/__init__.py

@@ -9,11 +9,13 @@ and listing template attributes.
 from tools.templates_tools.tool_create_edit_record import create_edit_record
 from tools.templates_tools.tool_list_attributes import list_attributes
 from tools.templates_tools.tool_list_records import list_template_records
+from tools.templates_tools.tools_form import get_form
 from tools.templates_tools.tools_record_template import edit_or_create_record_template
 
 __all__ = [
     "create_edit_record",
     "edit_or_create_record_template",
+    "get_form",
     "list_attributes",
     "list_template_records",
 ]

tools/templates_tools/tools_form.py

@@ -0,0 +1,104 @@
+from ..tool_utils import *
+
+FORM_ENDPOINT = "webapi/Form"
+
+
+class GetFormSchema(BaseModel):
+    application_system_name: str = Field(
+        description="System name of the application. RU: Системное имя приложения",
+    )
+    template_system_name: str = Field(
+        description="System name of the template. RU: Системное имя шаблона",
+    )
+    form_system_name: str = Field(
+        description="System name of the form. RU: Системное имя формы",
+    )
+
+    @field_validator(
+        "application_system_name",
+        "template_system_name",
+        "form_system_name",
+        mode="before",
+    )
+    @classmethod
+    def non_empty_str(cls, v: Any) -> Any:
+        if isinstance(v, str) and v.strip() == "":
+            msg = "must be a non-empty string"
+            raise ValueError(msg)
+        return v
+
+
+@tool(
+    "get_form",
+    return_direct=False,
+    args_schema=GetFormSchema,
+)
+def get_form(
+    application_system_name: str,
+    template_system_name: str,
+    form_system_name: str,
+) -> dict[str, Any]:
+    r"""
+    Fetch a form model.
+
+        Returns:
+        dict: {
+            "success": bool - True if the template was created or edited successfully
+            "status_code": int - HTTP response status code
+            "error": str|None - Error message if operation failed
+            form model fields: dict|list|None — Form structure without wrapper key (normalized)
+        }
+    """
+    form_global_alias = f"Form@{template_system_name}.{form_system_name}"
+    endpoint = f"{FORM_ENDPOINT}/{application_system_name}/{form_global_alias}"
+    result = execute_get_operation(AttributeResult, endpoint)
+
+    # Lean normalization: translate API terms to platform terminology
+    if result.get("success"):
+        result = _normalize_form_terms(result)
+
+    return result
+
+
+def _normalize_form_terms(data: dict) -> dict:
+    """
+    Lean normalization of API terms to platform terminology.
+    Translates 'alias' → 'systemName' and 'Property' → 'Attribute'
+    while preserving 'globalAlias' structures.
+    """
+    if not isinstance(data, dict):
+        return data
+
+    normalized = {}
+    for key, value in data.items():
+        # Rename 'alias' to 'systemName' (but not 'globalAlias')
+        if key == "alias":
+            normalized["systemName"] = value
+        elif "Alias" in key and not "globalalias" in key.lower():
+            normalized[key.replace("Alias", "SystemName")] = value
+        # Rename 'Property' to 'Attribute' in camelCase
+        elif "Property" in key:
+            normalized[key.replace("Property", "Attribute")] = value
+        # Recursively process nested structures
+        elif isinstance(value, dict):
+            normalized[key] = _normalize_form_terms(value)
+        elif isinstance(value, list):
+            normalized[key] = [
+                _normalize_form_terms(item) if isinstance(item, dict) else item
+                for item in value
+            ]
+        else:
+            normalized[key] = value
+
+    return normalized
+
+
+if __name__ == "__main__":
+    results = get_form.invoke({
+        "application_system_name": "Велестест",
+        "template_system_name": "Prichina_otkaza",
+        "form_system_name": "defaultForm"
+    })
+    print(results)
+
+

tools/templates_tools/tools_record_template.py

@@ -51,7 +51,7 @@ def edit_or_create_record_template(
         dict: {
             "success": bool - True if the template was created or edited successfully
             "status_code": int - HTTP response status code  
-            "raw_response": dict|str|None - Raw response for auditing or payload body (sanitized)
+            "raw_response": dict|str|None - template model (sanitized)
             "error": str|None - Error message if operation failed
         }
     """

tools/tool_utils.py

@@ -429,8 +429,10 @@ def rename_data(
     if isinstance(data, dict):
         # Определяем тип атрибута
         renamed_data = {}
-        
+
         # Добавляем описание типа атрибута как первый элемент
+        model_description = None
+        model_response = None
         for key, value in ENTITY_TYPE_MAPPING.items():
             if caller_name.__contains__(key):
                 model_description = value[0]