@hashgraphonline/conversational-agent 0.2.216 → 0.2.218

package/dist/esm/index11.js

@@ -1,319 +1,686 @@
-import { ZodError } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { extractRenderConfigs, generateFieldOrdering } from "@hashgraphonline/standards-agent-kit";
 import { Logger } from "@hashgraphonline/standards-sdk";
-import { FormGenerator } from "./index10.js";
-import { isFormValidatable } from "@hashgraphonline/standards-agent-kit";
-class FormEngine {
-  constructor(logger) {
-    this.formGenerator = new FormGenerator();
-    this.logger = logger || new Logger({ module: "FormEngine" });
+import { fieldTypeRegistry } from "./index13.js";
+import { fieldGuidanceRegistry } from "./index14.js";
+import "./index44.js";
+import { FIELD_PRIORITIES } from "./index60.js";
+function isZodObjectSchema(schema) {
+  return typeof schema === "object" && schema !== null && "shape" in schema;
+}
+class FormGenerator {
+  constructor() {
+    this.logger = new Logger({ module: "FormGenerator" });
   }
   /**
-   * Generate a form for a tool with the given input
+   * Creates a form message from a Zod validation error
+   * @param error The Zod validation error
+   * @param schema The original Zod schema
+   * @param toolName Name of the tool that failed validation
+   * @param originalPrompt The user's original request
+   * @returns FormMessage to send to the chat UI
    */
-  async generateForm(toolName, tool, input, context) {
-    const fullContext = {
-      tool,
-      input,
-      ...context
+  generateFormFromError(error, schema, toolName, originalPrompt) {
+    const validationErrors = this.extractValidationErrors(error);
+    const missingFields = this.identifyMissingFields(validationErrors, schema);
+    const formConfig = this.createFormConfig(schema, missingFields, toolName);
+    return {
+      type: "form",
+      id: `form_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      formConfig,
+      originalPrompt,
+      toolName,
+      validationErrors
     };
-    try {
-      if (isFormValidatable(tool)) {
-        return await this.generateFormValidatableForm(tool, input, fullContext);
-      }
-      if (input instanceof ZodError) {
-        return await this.generateErrorBasedForm(tool, input, fullContext);
-      }
-      if (this.hasRenderConfig(tool)) {
-        return await this.generateRenderConfigForm(tool, input, fullContext);
-      }
-      if (this.isZodObject(tool.schema)) {
-        return await this.generateSchemaBasedForm(tool, input, fullContext);
+  }
+  /**
+   * Generates a form from a schema and partial input
+   * @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, partialInput, context, preCalculatedMissingFields) {
+    let missingFields;
+    this.logger.info(`🏁 FormGenerator.generateFormFromSchema starting`, {
+      toolName: context.toolName,
+      partialInput,
+      hasSchema: !!schema,
+      hasShape: !!(schema && isZodObjectSchema(schema)),
+      hasPreCalculatedFields: preCalculatedMissingFields !== void 0,
+      preCalculatedFieldsSize: preCalculatedMissingFields?.size || 0
+    });
+    if (preCalculatedMissingFields !== void 0) {
+      missingFields = preCalculatedMissingFields;
+      this.logger.info(`📋 Using pre-calculated missing fields`, {
+        missingFieldsCount: missingFields.size,
+        missingFields: Array.from(missingFields)
+      });
+    } else {
+      missingFields = /* @__PURE__ */ new Set();
+      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}`
+          );
+        }
       }
-      return null;
-    } catch (error) {
-      this.logger.error(`Failed to generate form for tool: ${toolName}`, {
-        error: error instanceof Error ? error.message : String(error)
+      this.logger.info(`📋 Using ALL fields from focused schema`, {
+        totalFields: zodObject ? Object.keys(zodObject.shape).length : 0,
+        missingFieldsCount: missingFields.size,
+        missingFields: Array.from(missingFields)
       });
-      throw error;
     }
+    const formConfig = this.createFormConfig(
+      schema,
+      missingFields,
+      context.toolName,
+      preCalculatedMissingFields
+    );
+    return {
+      type: "form",
+      id: `form_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      formConfig,
+      originalPrompt: context.toolDescription || `Complete ${context.toolName}`,
+      toolName: context.toolName,
+      validationErrors: []
+    };
   }
   /**
-   * Process a form submission
+   * Extracts validation errors from ZodError
    */
-  async processSubmission(submission, context) {
-    this.validateSubmission(submission);
-    const baseToolInput = this.extractBaseToolInput(context);
-    const submissionData = this.extractSubmissionData(submission);
-    return this.mergeInputData(baseToolInput, submissionData);
+  extractValidationErrors(error) {
+    return error.issues.map((issue) => ({
+      path: issue.path.map((p) => String(p)),
+      message: issue.message,
+      code: issue.code
+    }));
   }
   /**
-   * Check if a tool requires form generation based on input
+   * Identifies which fields are missing or invalid from validation errors
    */
-  shouldGenerateForm(tool, input) {
-    const inputRecord = input;
-    if (inputRecord?.__fromForm === true || inputRecord?.renderForm === false) {
-      return false;
-    }
-    if (isFormValidatable(tool)) {
-      try {
-        const formValidatableTool = tool;
-        return formValidatableTool.shouldGenerateForm(input);
-      } catch (error) {
-        this.logger.error(
-          `Error calling shouldGenerateForm() on ${tool.name}:`,
-          error
-        );
-        return false;
+  identifyMissingFields(errors, _schema) {
+    const missingFields = /* @__PURE__ */ new Set();
+    errors.forEach((error) => {
+      const fieldPath = error.path.join(".");
+      if (fieldPath) {
+        missingFields.add(fieldPath);
       }
-    }
-    const validation = this.validateInput(tool, input);
-    return !validation.isValid;
+    });
+    return missingFields;
   }
   /**
-   * Generate form from error context
+   * Creates form configuration from schema
    */
-  async generateFormFromError(error, toolName, toolSchema, originalPrompt) {
-    return this.formGenerator.generateFormFromError(
-      error,
-      toolSchema,
+  createFormConfig(schema, missingFields, toolName, preCalculatedMissingFields) {
+    const extractedConfig = this.extractRenderConfigsSafely(schema);
+    const fieldOrdering = this.generateFieldOrderingSafely(schema);
+    const fields = this.generateFormFields(
+      schema,
+      extractedConfig,
+      missingFields,
+      fieldOrdering,
+      preCalculatedMissingFields,
+      toolName
+    );
+    const globalGuidance = fieldGuidanceRegistry.getGlobalGuidance(toolName);
+    let description = this.generateFormDescription(
       toolName,
-      originalPrompt
+      missingFields.size
     );
+    if (globalGuidance?.qualityStandards) {
+      description += "\n\nQuality Guidelines:\n" + globalGuidance.qualityStandards.map((standard) => `• ${standard}`).join("\n");
+    }
+    return {
+      title: this.generateFormTitle(toolName),
+      description,
+      fields,
+      submitLabel: "Continue",
+      cancelLabel: "Cancel",
+      metadata: {
+        toolName,
+        missingFieldCount: missingFields.size,
+        globalGuidance
+      }
+    };
   }
   /**
-   * Generate form for FormValidatable tools
+   * Safely extracts render configs from schema
    */
-  async generateFormValidatableForm(tool, input, _context) {
-    const { schemaToUse, isFocusedSchema } = this.resolveFormSchema(tool);
-    const missingFields = this.determineMissingFields(
-      tool,
-      input,
-      schemaToUse,
-      isFocusedSchema
-    );
-    return this.generateFormWithSchema(tool, input, schemaToUse, missingFields);
+  extractRenderConfigsSafely(schema) {
+    try {
+      if (typeof extractRenderConfigs === "function") {
+        return extractRenderConfigs(schema);
+      }
+    } catch (error) {
+      this.logger.warn("Could not extract render configs:", error);
+    }
+    return {
+      fields: {},
+      groups: {},
+      order: [],
+      metadata: {}
+    };
   }
   /**
-   * Generate form based on schema validation
+   * Safely generates field ordering from schema
    */
-  async generateSchemaBasedForm(tool, input, context) {
-    const schema = tool.schema;
-    const formMessage = await this.formGenerator.generateFormFromSchema(
-      schema,
-      input,
-      {
-        toolName: tool.name,
-        toolDescription: tool.description
-      },
-      context.missingFields
-    );
-    if (this.isZodObject(schema)) {
-      try {
-        const { jsonSchema, uiSchema } = this.formGenerator.generateJsonSchemaForm(
-          schema,
-          input,
-          context.missingFields || /* @__PURE__ */ new Set()
-        );
-        formMessage.jsonSchema = jsonSchema;
-        formMessage.uiSchema = uiSchema;
-      } catch (error) {
-        this.logger.warn(
-          "Failed to generate JSON Schema for schema-based tool:",
-          error
+  generateFieldOrderingSafely(schema) {
+    try {
+      if (typeof generateFieldOrdering === "function") {
+        const ordering = generateFieldOrdering(
+          schema
         );
+        const sections = Object.values(ordering.sections).map((section) => ({
+          fields: section.fields
+        }));
+        return { sections };
       }
+    } catch (error) {
+      this.logger.warn("Could not generate field ordering:", error);
     }
-    formMessage.partialInput = input;
-    return formMessage;
+    return { sections: [] };
   }
   /**
-   * Generate form based on render config
+   * Determines field priority for progressive disclosure
    */
-  async generateRenderConfigForm(tool, input, context) {
-    const schema = tool.schema;
-    const renderConfig = this.extractRenderConfig(tool);
-    const formMessage = await this.formGenerator.generateFormFromSchema(
-      schema,
-      input,
-      {
-        toolName: tool.name,
-        toolDescription: tool.description
-      },
-      context.missingFields
-    );
-    if (renderConfig) {
-      formMessage.formConfig.metadata = {
-        ...formMessage.formConfig.metadata,
-        renderConfig
-      };
+  getFieldPriority(name, renderConfig, isRequired) {
+    if (renderConfig?.ui?.priority) {
+      const priority = renderConfig.ui.priority;
+      if (Object.values(FIELD_PRIORITIES).includes(priority)) {
+        return priority;
+      }
+    }
+    if (isRequired === true) {
+      return FIELD_PRIORITIES.ESSENTIAL;
+    }
+    const ui = renderConfig?.ui;
+    if (ui?.advanced === true) {
+      return FIELD_PRIORITIES.ADVANCED;
     }
-    formMessage.partialInput = input;
-    return formMessage;
+    if (ui?.expert === true) {
+      return FIELD_PRIORITIES.EXPERT;
+    }
+    return FIELD_PRIORITIES.COMMON;
   }
   /**
-   * Generate form from Zod validation error
+   * Determines which fields should be included in the form
    */
-  async generateErrorBasedForm(tool, error, context) {
-    return this.formGenerator.generateFormFromError(
-      error,
-      tool.schema,
-      tool.name,
-      context.input ? String(context.input) : ""
-    );
+  determineFieldsToInclude(schema, missingFields, preCalculatedMissingFields) {
+    const fieldsToInclude = /* @__PURE__ */ new Set();
+    if (preCalculatedMissingFields === void 0) {
+      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 fieldsToInclude;
   }
   /**
-   * Validate input against tool schema
+   * Includes required fields that are missing
    */
-  validateInput(tool, input) {
-    try {
-      const zodSchema = tool.schema;
-      zodSchema.parse(input);
-      return { isValid: true };
-    } catch (error) {
-      if (error instanceof ZodError) {
-        const errors = error.errors.map(
-          (err) => `${err.path.join(".")}: ${err.message}`
-        );
-        return { isValid: false, errors };
+  includeRequiredMissingFields(schema, missingFields, fieldsToInclude) {
+    const allSchemaFields = this.extractFieldsFromSchema(schema);
+    allSchemaFields.forEach((fieldName) => {
+      const isRequired = this.isFieldRequired(schema, fieldName);
+      const isMissing = missingFields.has(fieldName);
+      const shouldInclude = isMissing && isRequired;
+      this.logger.info(`🔍 FormGenerator field inclusion check: ${fieldName}`, {
+        isRequired,
+        isMissing,
+        shouldInclude
+      });
+      if (shouldInclude) {
+        fieldsToInclude.add(fieldName);
       }
-      return { isValid: false, errors: ["Validation failed"] };
-    }
+    });
   }
   /**
-   * Check if schema is ZodObject
+   * Creates form fields from ordered field names
    */
-  isZodObject(schema) {
-    if (!schema || typeof schema !== "object") {
-      return false;
+  createOrderedFields(fieldsToInclude, fieldOrdering, extractedConfig, schema, toolName) {
+    const fields = [];
+    const processedFields = /* @__PURE__ */ new Set();
+    if (fieldOrdering.sections.length > 0) {
+      const orderedFieldNames = fieldOrdering.sections.flatMap((s) => s.fields);
+      orderedFieldNames.forEach((fieldName) => {
+        if (fieldsToInclude.has(fieldName) && !processedFields.has(fieldName)) {
+          const field = this.createFormField(
+            fieldName,
+            extractedConfig.fields[fieldName],
+            schema,
+            fieldName,
+            toolName
+          );
+          if (field) {
+            fields.push(field);
+            processedFields.add(fieldName);
+          }
+        }
+      });
     }
-    const candidate = schema;
-    return Boolean(candidate._def && candidate._def.typeName === "ZodObject");
-  }
-  /**
-   * Check if tool has render configuration
-   */
-  hasRenderConfig(tool) {
-    const schema = tool.schema;
-    return !!(schema && schema._renderConfig);
+    fieldsToInclude.forEach((fieldName) => {
+      if (!processedFields.has(fieldName)) {
+        const field = this.createFormField(
+          fieldName,
+          extractedConfig.fields[fieldName],
+          schema,
+          fieldName,
+          toolName
+        );
+        if (field) {
+          fields.push(field);
+        }
+      }
+    });
+    return fields;
   }
   /**
-   * Extract render configuration from tool
+   * Generates form fields from schema and validation errors
    */
-  extractRenderConfig(tool) {
-    const schema = tool.schema;
-    return schema?._renderConfig;
+  generateFormFields(schema, extractedConfig, missingFields, fieldOrdering, preCalculatedMissingFields, toolName) {
+    const fieldsToInclude = this.determineFieldsToInclude(
+      schema,
+      missingFields,
+      preCalculatedMissingFields
+    );
+    let fields = this.createOrderedFields(
+      fieldsToInclude,
+      fieldOrdering,
+      extractedConfig,
+      schema,
+      toolName
+    );
+    if (fields.length === 0 && missingFields.size > 0) {
+      fields = Array.from(missingFields).map(
+        (fieldName) => this.createFormField(
+          fieldName,
+          extractedConfig.fields[fieldName],
+          schema,
+          fieldName,
+          toolName
+        )
+      ).filter(
+        (field) => field !== null && field !== void 0
+      );
+    }
+    return fields;
   }
   /**
-   * Resolve form schema for FormValidatable tools
+   * Creates a single form field
    */
-  resolveFormSchema(tool) {
-    const formValidatableTool = tool;
-    if (formValidatableTool.getFormSchema) {
-      const focusedSchema = formValidatableTool.getFormSchema();
-      if (focusedSchema) {
-        return { schemaToUse: focusedSchema, isFocusedSchema: true };
+  createFormField(fieldName, renderConfig, schema, fieldPath, toolName) {
+    const type = this.mapFieldType(renderConfig?.fieldType, schema, fieldPath);
+    const isRequired = this.isFieldRequired(schema, fieldPath || fieldName);
+    const guidance = toolName ? fieldGuidanceRegistry.getFieldGuidance(toolName, fieldName) : null;
+    const finalType = guidance?.fieldTypeOverride || type;
+    const field = {
+      name: fieldName,
+      label: renderConfig?.ui?.label || this.humanizeFieldName(fieldName),
+      type: finalType,
+      required: isRequired,
+      priority: this.getFieldPriority(fieldName, renderConfig, isRequired)
+    };
+    if (guidance) {
+      if (guidance.suggestions && guidance.suggestions.length > 0) {
+        field.suggestions = guidance.suggestions;
+        if (!field.placeholder) {
+          field.placeholder = `e.g., ${guidance.suggestions[0]}`;
+        }
+      }
+      if (guidance.predefinedOptions) {
+        field.options = [
+          ...field.options || [],
+          ...guidance.predefinedOptions
+        ];
+      }
+      if (guidance.contextualHelpText) {
+        field.helpText = guidance.contextualHelpText;
+      }
+      if (guidance.warnings) {
+        field.warnings = guidance.warnings.map((w) => w.message);
+      }
+      if (guidance.validationRules) {
+        const { qualityChecks } = guidance.validationRules;
+        if (qualityChecks) {
+          field.contextualGuidance = {
+            qualityStandards: [],
+            examples: guidance.suggestions || [],
+            avoidPatterns: qualityChecks.forbidTechnicalTerms || []
+          };
+          if (qualityChecks.minNonTechnicalWords) {
+            field.contextualGuidance.qualityStandards?.push(
+              `Use at least ${qualityChecks.minNonTechnicalWords} meaningful words`
+            );
+          }
+          if (qualityChecks.forbidTechnicalTerms) {
+            field.contextualGuidance.qualityStandards?.push(
+              `Avoid technical terms like: ${qualityChecks.forbidTechnicalTerms.join(
+                ", "
+              )}`
+            );
+          }
+        }
+      }
+    }
+    if (renderConfig) {
+      field.renderConfig = renderConfig;
+    }
+    if (renderConfig?.ui?.placeholder) {
+      field.placeholder = renderConfig.ui.placeholder;
+    }
+    if (renderConfig?.ui?.helpText) {
+      field.helpText = renderConfig.ui.helpText;
+    }
+    if (renderConfig?.constraints) {
+      const validation = {};
+      if (renderConfig.constraints.min !== void 0)
+        validation.min = renderConfig.constraints.min;
+      if (renderConfig.constraints.max !== void 0)
+        validation.max = renderConfig.constraints.max;
+      if (renderConfig.constraints.minLength !== void 0)
+        validation.minLength = renderConfig.constraints.minLength;
+      if (renderConfig.constraints.maxLength !== void 0)
+        validation.maxLength = renderConfig.constraints.maxLength;
+      if (renderConfig.constraints.pattern !== void 0)
+        validation.pattern = renderConfig.constraints.pattern;
+      if (Object.keys(validation).length > 0) {
+        field.validation = validation;
       }
     }
-    return { schemaToUse: tool.schema, isFocusedSchema: false };
+    if (renderConfig?.options) {
+      field.options = renderConfig.options.map((opt) => ({
+        value: String(opt.value),
+        label: opt.label,
+        ...opt.disabled !== void 0 && { disabled: opt.disabled }
+      }));
+    }
+    return field;
   }
   /**
-   * Determine missing fields for form generation
+   * Maps render config field type to form field type with fallback inference
    */
-  determineMissingFields(tool, input, _schema, _isFocusedSchema) {
-    const missingFields = /* @__PURE__ */ new Set();
-    if (!input || typeof input !== "object") {
-      return missingFields;
+  mapFieldType(fieldType, schema, fieldPath) {
+    if (!fieldType && schema && fieldPath) {
+      const inferredType = this.inferTypeFromSchema(schema, fieldPath);
+      if (inferredType) {
+        return inferredType;
+      }
     }
-    const inputRecord = input;
-    const formValidatableTool = tool;
-    if (formValidatableTool.getEssentialFields) {
-      const essentialFields = formValidatableTool.getEssentialFields();
-      for (const field of essentialFields) {
-        if (!(field in inputRecord) || formValidatableTool.isFieldEmpty && formValidatableTool.isFieldEmpty(field, inputRecord[field])) {
-          missingFields.add(field);
-        }
+    if (!fieldType && fieldPath) {
+      const registryType = fieldTypeRegistry.detectType(fieldPath);
+      if (registryType) {
+        return registryType;
       }
     }
-    return missingFields;
+    if (!fieldType) {
+      return "text";
+    }
+    const normalizedType = fieldType.toLowerCase();
+    if (["text", "string"].includes(normalizedType)) return "text";
+    if (["number", "integer", "float", "decimal"].includes(normalizedType))
+      return "number";
+    if (["select", "enum", "dropdown"].includes(normalizedType))
+      return "select";
+    if (["checkbox", "boolean", "bool"].includes(normalizedType))
+      return "checkbox";
+    if (["textarea", "longtext", "multiline"].includes(normalizedType))
+      return "textarea";
+    if (["file", "upload", "attachment"].includes(normalizedType))
+      return "file";
+    if (["array", "list"].includes(normalizedType)) return "array";
+    if (["object", "json"].includes(normalizedType)) return "object";
+    if (["currency", "money", "price"].includes(normalizedType))
+      return "currency";
+    if (["percentage", "percent"].includes(normalizedType)) return "percentage";
+    return "text";
   }
   /**
-   * Generate form with resolved schema
+   * Converts field name to human-readable label
    */
-  async generateFormWithSchema(tool, input, schema, missingFields) {
-    const formMessage = await this.formGenerator.generateFormFromSchema(
-      schema,
-      input,
-      {
-        toolName: tool.name,
-        toolDescription: tool.description
-      },
-      missingFields
-    );
-    if (this.isZodObject(schema)) {
-      try {
-        const { jsonSchema, uiSchema } = this.formGenerator.generateJsonSchemaForm(
-          schema,
-          input,
-          missingFields
-        );
-        formMessage.jsonSchema = jsonSchema;
-        formMessage.uiSchema = uiSchema;
-      } catch (error) {
-        this.logger.warn("Failed to generate JSON Schema:", error);
-      }
-    }
-    formMessage.partialInput = input;
-    return formMessage;
+  humanizeFieldName(fieldName) {
+    return fieldName.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/\./g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
   }
   /**
-   * Validate form submission
+   * Generates a title for the form
    */
-  validateSubmission(submission) {
-    if (!submission.toolName) {
-      throw new Error("Tool name is required in form submission");
-    }
-    if (!submission.parameters) {
-      throw new Error("Parameters are required in form submission");
+  generateFormTitle(toolName) {
+    const cleanName = toolName.replace(/Tool$/, "").replace(/Hedera/g, "").replace(/([A-Z])/g, " $1").trim();
+    return `Complete ${cleanName} Information`;
+  }
+  /**
+   * Safely extracts ZodObject from a schema, returns null if not an object schema
+   */
+  extractZodObject(schema) {
+    try {
+      const def = schema._def;
+      if (def && def.typeName === "ZodObject") {
+        return schema;
+      }
+    } catch (error) {
+      this.logger.debug("Could not extract ZodObject from schema:", error);
     }
+    return null;
   }
   /**
-   * Extract base tool input from context
+   * Extracts field names from Zod schema structure
    */
-  extractBaseToolInput(context) {
-    return context?.originalInput || {};
+  extractFieldsFromSchema(schema) {
+    const fields = [];
+    const zodObject = this.extractZodObject(schema);
+    if (zodObject) {
+      fields.push(...Object.keys(zodObject.shape));
+      return fields;
+    }
+    try {
+      const def = schema._def;
+      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) {
+      this.logger.debug(
+        "Could not extract fields from schema structure:",
+        error
+      );
+    }
+    return fields;
   }
   /**
-   * Extract submission data
+   * Infers field type from Zod schema
    */
-  extractSubmissionData(submission) {
-    return {
-      ...submission.parameters,
-      __fromForm: true
-    };
+  inferTypeFromSchema(schema, fieldPath) {
+    try {
+      const zodObject = this.extractZodObject(schema);
+      if (!zodObject) return null;
+      const shape = zodObject.shape;
+      if (!shape) return null;
+      let fieldSchema = shape[fieldPath];
+      if (!fieldSchema) return null;
+      const fieldDef = fieldSchema._def;
+      if (fieldDef && fieldDef.typeName === "ZodOptional" && fieldDef.innerType) {
+        fieldSchema = fieldDef.innerType;
+      }
+      if (!fieldSchema || !fieldSchema._def) return null;
+      const typeDef = fieldSchema._def;
+      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);
+    }
+    return null;
   }
   /**
-   * Merge input data
+   * Determines if a field is required based on the Zod schema
    */
-  mergeInputData(baseInput, submissionData) {
-    return {
-      ...baseInput,
-      ...submissionData
-    };
+  isFieldRequired(schema, fieldPath) {
+    if (!schema || !fieldPath) {
+      return false;
+    }
+    try {
+      const zodObject = this.extractZodObject(schema);
+      if (!zodObject) return false;
+      const shape = zodObject.shape;
+      if (!shape || !shape[fieldPath]) return false;
+      const fieldSchema = shape[fieldPath];
+      if (!fieldSchema || !fieldSchema._def) return true;
+      const fieldDef = fieldSchema._def;
+      const typeName = fieldDef.typeName;
+      if (typeName === "ZodOptional") {
+        return false;
+      }
+      if (typeName === "ZodDefault") {
+        return false;
+      }
+      if (fieldDef.defaultValue !== void 0) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      this.logger.debug(
+        `Could not determine if field ${fieldPath} is required:`,
+        error
+      );
+    }
+    return false;
   }
   /**
-   * Get registered strategies
+   * Generates a description for the form
    */
-  getRegisteredStrategies() {
-    return ["FormValidatable", "SchemaBased", "RenderConfig", "ZodErrorBased"];
+  generateFormDescription(toolName, fieldCount) {
+    if (fieldCount === 0) {
+      return "Please provide the required information to continue with your request.";
+    }
+    return `Please provide the following ${fieldCount} required field${fieldCount !== 1 ? "s" : ""} to continue with your request.`;
   }
   /**
-   * Get registered middleware
+   * 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
    */
-  getRegisteredMiddleware() {
-    return ["FormSubmissionValidator"];
+  generateJsonSchemaForm(zodSchema, partialInput, missingFields) {
+    const fullJsonSchema = zodToJsonSchema(zodSchema, {
+      target: "jsonSchema7"
+    });
+    const uiSchema = {};
+    let jsonSchema = fullJsonSchema;
+    if (missingFields && missingFields.size > 0) {
+      const fullSchemaAsObject = fullJsonSchema;
+      if (fullSchemaAsObject.properties && typeof fullSchemaAsObject.properties === "object") {
+        const filteredSchema = {
+          ...fullSchemaAsObject,
+          type: "object",
+          properties: {},
+          required: []
+        };
+        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) => 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, void 0, 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"],
+              collapsed: true
+            }
+          };
+          break;
+      }
+    });
+    return { jsonSchema, uiSchema };
   }
 }
 export {
-  FormEngine
+  FormGenerator
 };
 //# sourceMappingURL=index11.js.map