@hashgraphonline/conversational-agent 0.1.215 → 0.1.217

package/src/forms/form-generator.ts

@@ -1,4 +1,5 @@
 import { z, ZodError } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
 import type {
   FormConfig,
   FormField,
@@ -16,6 +17,8 @@ import {
 import { Logger } from '@hashgraphonline/standards-sdk';
 import { fieldTypeRegistry } from './field-type-registry';
 
+type FieldPriority = 'essential' | 'common' | 'advanced' | 'expert';
+
 /**
  * Generates forms from Zod validation failures
  */
@@ -59,32 +62,58 @@ export class FormGenerator {
    * @param schema The Zod schema to generate a form from
    * @param partialInput Any partial input already provided
    * @param context Additional context about the tool
+   * @param preCalculatedMissingFields Optional pre-calculated missing fields set. If undefined, includes all fields from schema.
    * @returns FormMessage to send to the chat UI
    */
   async generateFormFromSchema(
     schema: z.ZodSchema,
-    partialInput: any,
-    context: { toolName: string; toolDescription?: string }
+    partialInput: unknown,
+    context: { toolName: string; toolDescription?: string },
+    preCalculatedMissingFields?: Set<string>
   ): Promise<FormMessage> {
-    const missingFields = new Set<string>();
+    let missingFields: Set<string>;
+
+    this.logger.info(`🏁 FormGenerator.generateFormFromSchema starting`, {
+      toolName: context.toolName,
+      partialInput,
+      hasSchema: !!schema,
+      hasShape: !!(schema && (schema as any).shape),
+      hasPreCalculatedFields: preCalculatedMissingFields !== undefined,
+      preCalculatedFieldsSize: preCalculatedMissingFields?.size || 0,
+    });
+
+    if (preCalculatedMissingFields !== undefined) {
+      missingFields = preCalculatedMissingFields;
+      this.logger.info(`📋 Using pre-calculated missing fields`, {
+        missingFieldsCount: missingFields.size,
+        missingFields: Array.from(missingFields),
+      });
+    } else {
+      missingFields = new Set<string>();
 
-    // Identify which fields are missing from the input
-    if (schema && (schema as any).shape) {
-      const shape = (schema as any).shape;
-      for (const fieldName of Object.keys(shape)) {
-        if (
-          partialInput[fieldName] === undefined ||
-          partialInput[fieldName] === ''
-        ) {
+      const zodObject = this.extractZodObject(schema);
+      if (zodObject) {
+        const shape = zodObject.shape;
+        for (const fieldName of Object.keys(shape)) {
           missingFields.add(fieldName);
+          this.logger.info(
+            `⭐ Including all fields from focused schema: ${fieldName}`
+          );
         }
       }
+
+      this.logger.info(`📋 Using ALL fields from focused schema`, {
+        totalFields: zodObject ? Object.keys(zodObject.shape).length : 0,
+        missingFieldsCount: missingFields.size,
+        missingFields: Array.from(missingFields),
+      });
     }
 
     const formConfig = this.createFormConfig(
       schema,
       missingFields,
-      context.toolName
+      context.toolName,
+      preCalculatedMissingFields
     );
 
     return {
@@ -113,7 +142,7 @@ export class FormGenerator {
    */
   private identifyMissingFields(
     errors: ValidationError[],
-    schema: z.ZodSchema
+    _schema: z.ZodSchema
   ): Set<string> {
     const missingFields = new Set<string>();
 
@@ -133,7 +162,8 @@ export class FormGenerator {
   private createFormConfig(
     schema: z.ZodSchema,
     missingFields: Set<string>,
-    toolName: string
+    toolName: string,
+    preCalculatedMissingFields?: Set<string>
   ): FormConfig {
     const extractedConfig = this.extractRenderConfigsSafely(schema);
     const fieldOrdering = this.generateFieldOrderingSafely(schema);
@@ -141,7 +171,8 @@ export class FormGenerator {
       schema,
       extractedConfig,
       missingFields,
-      fieldOrdering
+      fieldOrdering,
+      preCalculatedMissingFields
     );
 
     return {
@@ -165,7 +196,7 @@ export class FormGenerator {
   ): ExtractedRenderConfig {
     try {
       if (typeof extractRenderConfigs === 'function') {
-        return extractRenderConfigs(schema as ZodSchemaWithRender);
+        return extractRenderConfigs(schema as unknown as ZodSchemaWithRender);
       }
     } catch (error) {
       this.logger.warn('Could not extract render configs:', error);
@@ -186,8 +217,10 @@ export class FormGenerator {
   } {
     try {
       if (typeof generateFieldOrdering === 'function') {
-        const ordering = generateFieldOrdering(schema as ZodSchemaWithRender);
-        // Convert to expected format
+        const ordering = generateFieldOrdering(
+          schema as unknown as ZodSchemaWithRender
+        );
+
         const sections = Object.values(ordering.sections).map((section) => ({
           fields: section.fields,
         }));
@@ -200,78 +233,116 @@ export class FormGenerator {
   }
 
   /**
-   * Generates form fields from schema and validation errors
+   * Determines field priority for progressive disclosure
    */
-  private generateFormFields(
+  private getFieldPriority(
+    name: string,
+    renderConfig?: RenderConfigSchema,
+    isRequired?: boolean
+  ): FieldPriority {
+    if (renderConfig?.ui?.priority) {
+      const priority = renderConfig.ui.priority as string;
+      if (['essential', 'common', 'advanced', 'expert'].includes(priority)) {
+        return priority as FieldPriority;
+      }
+    }
+
+    if (isRequired === true) {
+      return 'essential';
+    }
+
+    const ui = renderConfig?.ui as Record<string, unknown> | undefined;
+    if (ui?.advanced === true) {
+      return 'advanced';
+    }
+
+    if (ui?.expert === true) {
+      return 'expert';
+    }
+
+    return 'common';
+  }
+
+  /**
+   * Determines which fields should be included in the form
+   */
+  private determineFieldsToInclude(
     schema: z.ZodSchema,
-    extractedConfig: ExtractedRenderConfig,
     missingFields: Set<string>,
-    fieldOrdering: { sections: Array<{ fields: string[] }> }
-  ): FormField[] {
-    const fields: FormField[] = [];
+    preCalculatedMissingFields?: Set<string>
+  ): Set<string> {
+    const fieldsToInclude = new Set<string>();
 
-    // Determine field priority for progressive disclosure
-    const getFieldPriority = (
-      name: string
-    ): 'essential' | 'common' | 'advanced' | 'expert' => {
-      const essentialFields = [
-        'tokenSymbol',
-        'treasuryAccountId',
-        'maxSupply',
-        'tokenName',
-        'name',
-        'description',
-        'contentRef',
-      ];
-      const commonFields = ['creator', 'type', 'fileStandard', 'supplyType'];
-      const expertFields = [
-        'apiKey',
-        'chunkSize',
-        'timeoutMs',
-        'quoteOnly',
-        'waitForConfirmation',
-      ];
-
-      if (essentialFields.includes(name)) return 'essential';
-      if (commonFields.includes(name)) return 'common';
-      if (expertFields.includes(name)) return 'expert';
-
-      // Keys and technical fields are advanced
-      if (
-        name.toLowerCase().includes('key') ||
-        name.includes('Period') ||
-        name.includes('Fees') ||
-        name.includes('autoRenew')
-      ) {
-        return 'advanced';
-      }
+    if (preCalculatedMissingFields === undefined) {
+      this.logger.info(
+        `⭐ Focused schema mode - including ALL fields from schema`
+      );
+      const allSchemaFields = this.extractFieldsFromSchema(schema);
+      allSchemaFields.forEach((fieldName) => {
+        fieldsToInclude.add(fieldName);
+        this.logger.info(`✅ Including focused schema field: ${fieldName}`);
+      });
+    } else if (preCalculatedMissingFields.size > 0) {
+      this.logger.info(
+        `📋 Using ONLY pre-calculated missing fields (${preCalculatedMissingFields.size} fields)`,
+        { fields: Array.from(preCalculatedMissingFields) }
+      );
+      preCalculatedMissingFields.forEach((fieldName) => {
+        fieldsToInclude.add(fieldName);
+        this.logger.info(`✅ Including pre-calculated field: ${fieldName}`);
+      });
+    } else {
+      this.logger.info(
+        '⚠️ No pre-calculated fields, falling back to schema analysis'
+      );
+      this.includeRequiredMissingFields(schema, missingFields, fieldsToInclude);
+    }
 
-      return 'advanced'; // Default to advanced for unknown fields
-    };
+    return fieldsToInclude;
+  }
 
-    // For progressive disclosure, include only required fields and essential fields that are missing
+  /**
+   * Includes required fields that are missing
+   */
+  private includeRequiredMissingFields(
+    schema: z.ZodSchema,
+    missingFields: Set<string>,
+    fieldsToInclude: Set<string>
+  ): void {
     const allSchemaFields = this.extractFieldsFromSchema(schema);
-    const fieldsToInclude = new Set<string>();
-
     allSchemaFields.forEach((fieldName) => {
-      const priority = getFieldPriority(fieldName);
       const isRequired = this.isFieldRequired(schema, fieldName);
+      const isMissing = missingFields.has(fieldName);
+      const shouldInclude = isMissing && isRequired;
 
-      // Include field if it's missing and required, or if it's essential (so users see key fields)
-      if (
-        (missingFields.has(fieldName) && isRequired) ||
-        priority === 'essential'
-      ) {
+      this.logger.info(`🔍 FormGenerator field inclusion check: ${fieldName}`, {
+        isRequired,
+        isMissing,
+        shouldInclude,
+      });
+
+      if (shouldInclude) {
         fieldsToInclude.add(fieldName);
       }
     });
+  }
+
+  /**
+   * Creates form fields from ordered field names
+   */
+  private createOrderedFields(
+    fieldsToInclude: Set<string>,
+    fieldOrdering: { sections: Array<{ fields: string[] }> },
+    extractedConfig: ExtractedRenderConfig,
+    schema: z.ZodSchema
+  ): FormField[] {
+    const fields: FormField[] = [];
+    const processedFields = new Set<string>();
 
-    // If we have field ordering from render configs, use that first
     if (fieldOrdering.sections.length > 0) {
       const orderedFieldNames = fieldOrdering.sections.flatMap((s) => s.fields);
-
       orderedFieldNames.forEach((fieldName) => {
-        if (fieldsToInclude.has(fieldName)) {
+        if (fieldsToInclude.has(fieldName) && !processedFields.has(fieldName)) {
           const field = this.createFormField(
             fieldName,
             extractedConfig.fields[fieldName],
@@ -280,15 +351,14 @@ export class FormGenerator {
           );
           if (field) {
             fields.push(field);
+            processedFields.add(fieldName);
           }
         }
       });
     }
 
-    // Add any remaining fields not in ordering
     fieldsToInclude.forEach((fieldName) => {
-      // Don't duplicate fields already added
-      if (!fields.some((f) => f.name === fieldName)) {
+      if (!processedFields.has(fieldName)) {
         const field = this.createFormField(
           fieldName,
           extractedConfig.fields[fieldName],
@@ -301,19 +371,45 @@ export class FormGenerator {
       }
     });
 
-    // If still no fields (shouldn't happen), fall back to missing fields
-    if (fields.length === 0) {
-      missingFields.forEach((fieldName) => {
-        const field = this.createFormField(
-          fieldName,
-          extractedConfig.fields[fieldName],
-          schema,
-          fieldName
+    return fields;
+  }
+
+  /**
+   * Generates form fields from schema and validation errors
+   */
+  private generateFormFields(
+    schema: z.ZodSchema,
+    extractedConfig: ExtractedRenderConfig,
+    missingFields: Set<string>,
+    fieldOrdering: { sections: Array<{ fields: string[] }> },
+    preCalculatedMissingFields?: Set<string>
+  ): FormField[] {
+    const fieldsToInclude = this.determineFieldsToInclude(
+      schema,
+      missingFields,
+      preCalculatedMissingFields
+    );
+
+    let fields = this.createOrderedFields(
+      fieldsToInclude,
+      fieldOrdering,
+      extractedConfig,
+      schema
+    );
+
+    if (fields.length === 0 && missingFields.size > 0) {
+      fields = Array.from(missingFields)
+        .map((fieldName) =>
+          this.createFormField(
+            fieldName,
+            extractedConfig.fields[fieldName],
+            schema,
+            fieldName
+          )
+        )
+        .filter(
+          (field): field is FormField => field !== null && field !== undefined
         );
-        if (field) {
-          fields.push(field);
-        }
-      });
     }
 
     return fields;
@@ -329,47 +425,6 @@ export class FormGenerator {
     fieldPath?: string
   ): FormField {
     const type = this.mapFieldType(renderConfig?.fieldType, schema, fieldPath);
-
-    // Determine field priority for progressive disclosure
-    const getFieldPriority = (
-      name: string
-    ): 'essential' | 'common' | 'advanced' | 'expert' => {
-      const essentialFields = [
-        'tokenSymbol',
-        'treasuryAccountId',
-        'maxSupply',
-        'tokenName',
-        'name',
-        'description',
-        'contentRef',
-      ];
-      const commonFields = ['creator', 'type', 'fileStandard', 'supplyType'];
-      const expertFields = [
-        'apiKey',
-        'chunkSize',
-        'timeoutMs',
-        'quoteOnly',
-        'waitForConfirmation',
-      ];
-
-      if (essentialFields.includes(name)) return 'essential';
-      if (commonFields.includes(name)) return 'common';
-      if (expertFields.includes(name)) return 'expert';
-
-      // Keys and technical fields are advanced
-      if (
-        name.toLowerCase().includes('key') ||
-        name.includes('Period') ||
-        name.includes('Fees') ||
-        name.includes('autoRenew')
-      ) {
-        return 'advanced';
-      }
-
-      return 'advanced'; // Default to advanced for unknown fields
-    };
-
-    // Determine if field is required from schema
     const isRequired = this.isFieldRequired(schema, fieldPath || fieldName);
 
     const field: FormField = {
@@ -377,7 +432,7 @@ export class FormGenerator {
       label: renderConfig?.ui?.label || this.humanizeFieldName(fieldName),
       type,
       required: isRequired,
-      priority: getFieldPriority(fieldName),
+      priority: this.getFieldPriority(fieldName, renderConfig, isRequired),
     };
 
     if (renderConfig) {
@@ -429,7 +484,6 @@ export class FormGenerator {
     schema?: z.ZodSchema,
     fieldPath?: string
   ): FormFieldType {
-    // First try schema inference if no explicit fieldType
     if (!fieldType && schema && fieldPath) {
       const inferredType = this.inferTypeFromSchema(schema, fieldPath);
       if (inferredType) {
@@ -437,7 +491,6 @@ export class FormGenerator {
       }
     }
 
-    // If no fieldType and schema inference failed, use registry pattern detection
     if (!fieldType && fieldPath) {
       const registryType = fieldTypeRegistry.detectType(fieldPath);
       if (registryType) {
@@ -498,24 +551,45 @@ export class FormGenerator {
     return `Complete ${cleanName} Information`;
   }
 
+  /**
+   * Safely extracts ZodObject from a schema, returns null if not an object schema
+   */
+  private extractZodObject(
+    schema: z.ZodSchema
+  ): z.ZodObject<z.ZodRawShape> | null {
+    try {
+      const def = (schema as z.ZodType)._def as { typeName?: string };
+      if (def && def.typeName === 'ZodObject') {
+        return schema as z.ZodObject<z.ZodRawShape>;
+      }
+    } catch (error) {
+      this.logger.debug('Could not extract ZodObject from schema:', error);
+    }
+    return null;
+  }
+
   /**
    * Extracts field names from Zod schema structure
    */
   private extractFieldsFromSchema(schema: z.ZodSchema): string[] {
     const fields: string[] = [];
 
+    const zodObject = this.extractZodObject(schema);
+    if (zodObject) {
+      fields.push(...Object.keys(zodObject.shape));
+      return fields;
+    }
+
     try {
-      if (schema && (schema as any)._def) {
-        const def = (schema as any)._def;
-
-        if (def.typeName === 'ZodObject' && def.shape) {
-          fields.push(...Object.keys(def.shape));
-        } else if (def.typeName === 'ZodUnion' && def.options) {
-          // For unions, try to extract from the first option
-          const firstOption = def.options[0];
-          if (firstOption && firstOption._def && firstOption._def.shape) {
-            fields.push(...Object.keys(firstOption._def.shape));
-          }
+      const def = (schema as z.ZodType)._def as {
+        typeName?: string;
+        options?: z.ZodType[];
+      };
+      if (def && def.typeName === 'ZodUnion' && def.options) {
+        const firstOption = def.options[0];
+        const firstOptionObject = this.extractZodObject(firstOption);
+        if (firstOptionObject) {
+          fields.push(...Object.keys(firstOptionObject.shape));
         }
       }
     } catch (error) {
@@ -536,67 +610,58 @@ export class FormGenerator {
     fieldPath: string
   ): FormFieldType | null {
     try {
-      const def = (schema as any)._def;
+      const zodObject = this.extractZodObject(schema);
+      if (!zodObject) return null;
 
-      if (def && def.typeName === 'ZodObject') {
-        let shape;
-        if (typeof def.shape === 'function') {
-          shape = def.shape();
-        } else {
-          shape = def.shape;
-        }
+      const shape = zodObject.shape;
+      if (!shape) return null;
 
-        if (shape) {
-          let fieldSchema = shape[fieldPath];
+      let fieldSchema = shape[fieldPath] as z.ZodType | undefined;
+      if (!fieldSchema) return null;
 
-          // Handle optional fields by unwrapping ZodOptional
-          if (
-            fieldSchema &&
-            fieldSchema._def &&
-            fieldSchema._def.typeName === 'ZodOptional'
-          ) {
-            fieldSchema = fieldSchema._def.innerType;
-          }
+      const fieldDef = fieldSchema._def as {
+        typeName?: string;
+        innerType?: z.ZodType;
+      };
+      if (
+        fieldDef &&
+        fieldDef.typeName === 'ZodOptional' &&
+        fieldDef.innerType
+      ) {
+        fieldSchema = fieldDef.innerType;
+      }
+
+      if (!fieldSchema || !fieldSchema._def) return null;
 
-          if (fieldSchema && fieldSchema._def) {
-            const fieldTypeName = fieldSchema._def.typeName;
-
-            switch (fieldTypeName) {
-              case 'ZodString':
-                // Check for special string patterns
-                if (
-                  fieldPath.toLowerCase().includes('memo') ||
-                  fieldPath.toLowerCase().includes('description')
-                ) {
-                  return 'textarea';
-                }
-                return 'text';
-              case 'ZodNumber':
-                // Check for special number patterns
-                if (fieldPath.toLowerCase().includes('percent')) {
-                  return 'percentage';
-                }
-                if (
-                  fieldPath.toLowerCase().includes('price') ||
-                  fieldPath.toLowerCase().includes('cost')
-                ) {
-                  return 'currency';
-                }
-                return 'number';
-              case 'ZodBoolean':
-                return 'checkbox';
-              case 'ZodEnum':
-              case 'ZodNativeEnum':
-                return 'select';
-              case 'ZodArray':
-                return 'array';
-              case 'ZodObject':
-                return 'object';
-              default:
-                return 'text';
-            }
+      const typeDef = fieldSchema._def as { typeName?: string };
+      const fieldTypeName = typeDef.typeName;
+      const lowerPath = fieldPath.toLowerCase();
+
+      switch (fieldTypeName) {
+        case 'ZodString':
+          if (lowerPath.includes('memo') || lowerPath.includes('description')) {
+            return 'textarea';
           }
-        }
+          return 'text';
+        case 'ZodNumber':
+          if (lowerPath.includes('percent')) {
+            return 'percentage';
+          }
+          if (lowerPath.includes('price') || lowerPath.includes('cost')) {
+            return 'currency';
+          }
+          return 'number';
+        case 'ZodBoolean':
+          return 'checkbox';
+        case 'ZodEnum':
+        case 'ZodNativeEnum':
+          return 'select';
+        case 'ZodArray':
+          return 'array';
+        case 'ZodObject':
+          return 'object';
+        default:
+          return 'text';
       }
     } catch (error) {
       this.logger.debug('Could not infer type from schema:', error);
@@ -609,53 +674,38 @@ export class FormGenerator {
    */
   private isFieldRequired(schema?: z.ZodSchema, fieldPath?: string): boolean {
     if (!schema || !fieldPath) {
-      return false; // If we can't determine, assume optional
+      return false;
     }
 
     try {
-      const def = (schema as any)._def;
+      const zodObject = this.extractZodObject(schema);
+      if (!zodObject) return false;
 
-      if (def && def.typeName === 'ZodObject') {
-        let shape;
-        if (typeof def.shape === 'function') {
-          shape = def.shape();
-        } else {
-          shape = def.shape;
-        }
+      const shape = zodObject.shape;
+      if (!shape || !shape[fieldPath]) return false;
 
-        if (shape && shape[fieldPath]) {
-          const fieldSchema = shape[fieldPath];
+      const fieldSchema = shape[fieldPath] as z.ZodType;
+      if (!fieldSchema || !fieldSchema._def) return true;
 
-          // Check if field is wrapped in ZodOptional
-          if (
-            fieldSchema &&
-            fieldSchema._def &&
-            fieldSchema._def.typeName === 'ZodOptional'
-          ) {
-            return false; // Optional field
-          }
+      const fieldDef = fieldSchema._def as {
+        typeName?: string;
+        defaultValue?: unknown;
+      };
+      const typeName = fieldDef.typeName;
 
-          // Check if field has a default value (making it effectively optional)
-          if (
-            fieldSchema &&
-            fieldSchema._def &&
-            fieldSchema._def.defaultValue !== undefined
-          ) {
-            return false; // Has default, so optional
-          }
+      if (typeName === 'ZodOptional') {
+        return false;
+      }
 
-          // Check for ZodDefault wrapper
-          if (
-            fieldSchema &&
-            fieldSchema._def &&
-            fieldSchema._def.typeName === 'ZodDefault'
-          ) {
-            return false; // Has default, so optional
-          }
+      if (typeName === 'ZodDefault') {
+        return false;
+      }
 
-          return true; // Required field
-        }
+      if (fieldDef.defaultValue !== undefined) {
+        return false;
       }
+
+      return true;
     } catch (error) {
       this.logger.debug(
         `Could not determine if field ${fieldPath} is required:`,
@@ -663,7 +713,7 @@ export class FormGenerator {
       );
     }
 
-    return false; // Default to optional if we can't determine
+    return false;
   }
 
   /**
@@ -681,4 +731,111 @@ export class FormGenerator {
       fieldCount !== 1 ? 's' : ''
     } to continue with your request.`;
   }
+
+  /**
+   * Generates JSON Schema and uiSchema from a Zod schema for use with @rjsf/core
+   * @param zodSchema The Zod schema to convert
+   * @param partialInput Existing input data to filter out fields that already have values
+   * @param missingFields Set of fields that are missing and should be shown
+   * @returns Object containing jsonSchema and uiSchema
+   */
+  public generateJsonSchemaForm(
+    zodSchema: z.ZodObject<z.ZodRawShape>,
+    partialInput?: Record<string, unknown>,
+    missingFields?: Set<string>
+  ) {
+    const fullJsonSchema = zodToJsonSchema(zodSchema, {
+      target: 'jsonSchema7',
+    });
+
+    const uiSchema: Record<string, Record<string, unknown>> = {};
+
+    let jsonSchema = fullJsonSchema;
+    if (missingFields && missingFields.size > 0) {
+      const fullSchemaAsObject = fullJsonSchema as {
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+      };
+      if (
+        fullSchemaAsObject.properties &&
+        typeof fullSchemaAsObject.properties === 'object'
+      ) {
+        const filteredSchema = {
+          ...fullSchemaAsObject,
+          type: 'object' as const,
+          properties: {} as Record<string, unknown>,
+          required: [] as string[],
+        };
+
+        let fieldsAdded = 0;
+        missingFields.forEach((fieldName) => {
+          if (
+            fullSchemaAsObject.properties &&
+            fullSchemaAsObject.properties[fieldName]
+          ) {
+            filteredSchema.properties[fieldName] =
+              fullSchemaAsObject.properties[fieldName];
+            fieldsAdded++;
+          }
+        });
+
+        if (Array.isArray(fullSchemaAsObject.required)) {
+          filteredSchema.required = fullSchemaAsObject.required.filter(
+            (field: string) => missingFields.has(field)
+          );
+        }
+
+        if (fieldsAdded > 0) {
+          jsonSchema = filteredSchema;
+        }
+      }
+    }
+
+    const fieldNames = this.extractFieldsFromSchema(zodSchema);
+
+    fieldNames.forEach((fieldName) => {
+      const isRequired = this.isFieldRequired(zodSchema, fieldName);
+      const priority = this.getFieldPriority(fieldName, undefined, isRequired);
+      const lower = fieldName.toLowerCase();
+
+      if (
+        lower === 'attributes' ||
+        lower === 'metadata' ||
+        lower === 'properties'
+      ) {
+        uiSchema[fieldName] = {
+          'ui:options': {
+            collapsible: true,
+            collapsed: true,
+          },
+        };
+      }
+
+      switch (priority) {
+        case 'essential':
+          if (isRequired) {
+            uiSchema[fieldName] = {
+              ...uiSchema[fieldName],
+              'ui:help': 'Required field',
+            };
+          }
+          break;
+        case 'advanced':
+        case 'expert':
+          uiSchema[fieldName] = {
+            ...uiSchema[fieldName],
+            'ui:options': {
+              ...(uiSchema[fieldName]?.['ui:options'] as
+                | Record<string, unknown>
+                | undefined),
+              collapsed: true,
+            },
+          };
+          break;
+      }
+    });
+
+    return { jsonSchema, uiSchema };
+  }
 }