@elizaos/plugin-form 2.0.0-alpha.10 → 2.0.0-alpha.11

package/dist/chunk-4B5QLNVA.js

@@ -0,0 +1,187 @@
+import {
+  buildTemplateValues,
+  renderTemplate,
+  resolveControlTemplates
+} from "./chunk-WY4WK3HD.js";
+
+// src/providers/context.ts
+import { logger } from "@elizaos/core";
+var formContextProvider = {
+  name: "FORM_CONTEXT",
+  description: "Provides context about active form sessions",
+  /**
+   * Get form context for the current message.
+   *
+   * @param runtime - Agent runtime for service access
+   * @param message - The user message being processed
+   * @param _state - Current agent state (unused)
+   * @returns Provider result with form context (data, values, text)
+   */
+  get: async (runtime, message, _state) => {
+    try {
+      const formService = runtime.getService("FORM");
+      if (!formService) {
+        return { data: { hasActiveForm: false }, values: { formContext: "" }, text: "" };
+      }
+      const entityId = message.entityId;
+      const roomId = message.roomId;
+      if (!entityId || !roomId) {
+        return { data: { hasActiveForm: false }, values: { formContext: "" }, text: "" };
+      }
+      const session = await formService.getActiveSession(entityId, roomId);
+      const stashed = await formService.getStashedSessions(entityId);
+      if (!session && stashed.length === 0) {
+        return {
+          data: { hasActiveForm: false, stashedCount: 0 },
+          values: { formContext: "" },
+          text: ""
+        };
+      }
+      let contextText = "";
+      let contextState;
+      if (session) {
+        contextState = formService.getSessionContext(session);
+        const form = formService.getForm(session.formId);
+        const templateValues = buildTemplateValues(session);
+        const resolve = (v) => renderTemplate(v, templateValues);
+        contextState = {
+          ...contextState,
+          filledFields: contextState.filledFields.map((f) => ({
+            ...f,
+            label: resolve(f.label) ?? f.label
+          })),
+          missingRequired: contextState.missingRequired.map((f) => ({
+            ...f,
+            label: resolve(f.label) ?? f.label,
+            description: resolve(f.description),
+            askPrompt: resolve(f.askPrompt)
+          })),
+          uncertainFields: contextState.uncertainFields.map((f) => ({
+            ...f,
+            label: resolve(f.label) ?? f.label
+          })),
+          nextField: contextState.nextField ? resolveControlTemplates(contextState.nextField, templateValues) : null
+        };
+        const controls = form?.controls ?? [];
+        const filledKeys = new Set(contextState.filledFields.map((f) => f.key));
+        const controlByKey = new Map(controls.map((c) => [c.key, c]));
+        const requiredFilled = contextState.filledFields.filter(
+          (f) => controlByKey.get(f.key)?.required
+        );
+        const optionalFilled = contextState.filledFields.filter(
+          (f) => !controlByKey.get(f.key)?.required
+        );
+        const optionalMissing = controls.filter(
+          (c) => !c.hidden && !c.required && !filledKeys.has(c.key)
+        );
+        const fmt = (items) => items.length === 0 ? "none" : items.map((i) => i.displayValue ? `${i.key} (${i.displayValue})` : i.key).join(", ");
+        contextText = `# Active Form: ${form?.name || session.formId}
+`;
+        contextText += `Progress: ${contextState.progress}%
+
+`;
+        contextText += `Required fields we don't have: ${fmt(contextState.missingRequired)}
+`;
+        contextText += `Required fields we do have: ${fmt(requiredFilled)}
+
+`;
+        contextText += `Optional fields we don't have: ${fmt(optionalMissing)}
+`;
+        contextText += `Optional fields we do have: ${fmt(optionalFilled)}
+
+`;
+        if (contextState.uncertainFields.length > 0) {
+          contextText += `Needs confirmation:
+`;
+          for (const f of contextState.uncertainFields) {
+            contextText += `- ${f.label}: "${f.value}" (${Math.round(f.confidence * 100)}% confident)
+`;
+          }
+          contextText += "\n";
+        }
+        if (contextState.pendingExternalFields.length > 0) {
+          contextText += `Waiting for external action:
+`;
+          for (const f of contextState.pendingExternalFields) {
+            const mins = Math.floor((Date.now() - f.activatedAt) / 6e4);
+            contextText += `- ${f.label}: ${f.instructions} (${mins < 1 ? "just now" : `${mins}m ago`})`;
+            if (f.address) contextText += ` Address: ${f.address}`;
+            contextText += "\n";
+          }
+          contextText += "\n";
+        }
+        if (contextState.pendingExternalFields.length > 0) {
+          const p = contextState.pendingExternalFields[0];
+          contextText += `Instruction: Waiting for external action. Remind user: "${p.instructions}"
+`;
+        } else if (contextState.pendingCancelConfirmation) {
+          contextText += `Instruction: User is trying to cancel. Confirm they really want to lose progress.
+`;
+        } else if (contextState.uncertainFields.length > 0) {
+          const u = contextState.uncertainFields[0];
+          contextText += `Instruction: Ask user to confirm "${u.label}" = "${u.value}".
+`;
+        } else if (contextState.missingRequired.length > 0) {
+          contextText += `Instruction: Please nudge the user into helping complete required fields. The user can provide one or several answers in a single message; the form accepts them all.
+`;
+        } else if (contextState.status === "ready") {
+          contextText += `Instruction: All required fields collected. Nudge user to submit.
+`;
+        } else if (optionalMissing.length > 0) {
+          contextText += `Instruction: Required fields are done. Optionally nudge for remaining optional fields, or nudge to submit.
+`;
+        }
+      } else {
+        contextState = {
+          hasActiveForm: false,
+          progress: 0,
+          filledFields: [],
+          missingRequired: [],
+          uncertainFields: [],
+          nextField: null,
+          stashedCount: stashed.length,
+          pendingExternalFields: []
+        };
+      }
+      if (stashed.length > 0) {
+        contextText += `
+Saved forms: User has ${stashed.length} saved form(s). They can say "resume" to restore one.
+`;
+        for (const s of stashed) {
+          const f = formService.getForm(s.formId);
+          const ctx = formService.getSessionContext(s);
+          contextText += `- ${f?.name || s.formId} (${ctx.progress}% complete)
+`;
+        }
+      }
+      return {
+        // Full context object for programmatic access
+        // WHY: Restore action and others read data.nextField, data.filledFields, etc.
+        data: JSON.parse(JSON.stringify(contextState)),
+        // String values for template substitution (e.g. in prompts: formContext, formProgress, formStatus)
+        values: {
+          formContext: contextText,
+          hasActiveForm: String(contextState.hasActiveForm),
+          formProgress: String(contextState.progress),
+          formStatus: contextState.status || "",
+          stashedCount: String(stashed.length)
+        },
+        // Human-readable text for agent (injected into prompt)
+        text: contextText
+      };
+    } catch (error) {
+      logger.error("[FormContextProvider] Error:", String(error));
+      return {
+        data: { hasActiveForm: false, error: true },
+        values: { formContext: "Error loading form context." },
+        text: "Error loading form context."
+      };
+    }
+  }
+};
+var context_default = formContextProvider;
+
+export {
+  formContextProvider,
+  context_default
+};

package/dist/chunk-ARWZY3NX.js

@@ -0,0 +1,284 @@
+// src/validation.ts
+var typeHandlers = /* @__PURE__ */ new Map();
+function registerTypeHandler(type, handler) {
+  typeHandlers.set(type, handler);
+}
+function getTypeHandler(type) {
+  return typeHandlers.get(type);
+}
+function clearTypeHandlers() {
+  typeHandlers.clear();
+}
+function validateField(value, control) {
+  if (control.required) {
+    if (value === void 0 || value === null || value === "") {
+      return {
+        valid: false,
+        error: `${control.label || control.key} is required`
+      };
+    }
+  }
+  if (value === void 0 || value === null || value === "") {
+    return { valid: true };
+  }
+  const handler = typeHandlers.get(control.type);
+  if (handler?.validate) {
+    const result = handler.validate(value, control);
+    if (!result.valid) {
+      return result;
+    }
+  }
+  switch (control.type) {
+    case "email":
+      return validateEmail(value, control);
+    case "number":
+      return validateNumber(value, control);
+    case "boolean":
+      return validateBoolean(value, control);
+    case "date":
+      return validateDate(value, control);
+    case "select":
+      return validateSelect(value, control);
+    case "file":
+      return validateFile(value, control);
+    default:
+      return validateText(value, control);
+  }
+}
+function validateText(value, control) {
+  const strValue = String(value);
+  if (control.pattern) {
+    const regex = new RegExp(control.pattern);
+    if (!regex.test(strValue)) {
+      return {
+        valid: false,
+        error: `${control.label || control.key} has invalid format`
+      };
+    }
+  }
+  if (control.minLength !== void 0 && strValue.length < control.minLength) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be at least ${control.minLength} characters`
+    };
+  }
+  if (control.maxLength !== void 0 && strValue.length > control.maxLength) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be at most ${control.maxLength} characters`
+    };
+  }
+  if (control.enum && control.enum.length > 0) {
+    if (!control.enum.includes(strValue)) {
+      return {
+        valid: false,
+        error: `${control.label || control.key} must be one of: ${control.enum.join(", ")}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function validateEmail(value, control) {
+  const strValue = String(value);
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(strValue)) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be a valid email address`
+    };
+  }
+  return validateText(value, control);
+}
+function validateNumber(value, control) {
+  const numValue = typeof value === "number" ? value : parseFloat(String(value).replace(/[,$]/g, ""));
+  if (Number.isNaN(numValue)) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be a number`
+    };
+  }
+  if (control.min !== void 0 && numValue < control.min) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be at least ${control.min}`
+    };
+  }
+  if (control.max !== void 0 && numValue > control.max) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be at most ${control.max}`
+    };
+  }
+  return { valid: true };
+}
+function validateBoolean(value, _control) {
+  if (typeof value === "boolean") {
+    return { valid: true };
+  }
+  const strValue = String(value).toLowerCase();
+  const truthy = ["true", "yes", "1", "on"];
+  const falsy = ["false", "no", "0", "off"];
+  if (truthy.includes(strValue) || falsy.includes(strValue)) {
+    return { valid: true };
+  }
+  return { valid: false, error: "Must be true or false" };
+}
+function validateDate(value, control) {
+  let dateValue;
+  if (value instanceof Date) {
+    dateValue = value;
+  } else if (typeof value === "string" || typeof value === "number") {
+    dateValue = new Date(value);
+  } else {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be a valid date`
+    };
+  }
+  if (Number.isNaN(dateValue.getTime())) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be a valid date`
+    };
+  }
+  if (control.min !== void 0 && dateValue.getTime() < control.min) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} is too early`
+    };
+  }
+  if (control.max !== void 0 && dateValue.getTime() > control.max) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} is too late`
+    };
+  }
+  return { valid: true };
+}
+function validateSelect(value, control) {
+  if (!control.options || control.options.length === 0) {
+    return { valid: true };
+  }
+  const strValue = String(value);
+  const validValues = control.options.map((opt) => opt.value);
+  if (!validValues.includes(strValue)) {
+    return {
+      valid: false,
+      error: `${control.label || control.key} must be one of the available options`
+    };
+  }
+  return { valid: true };
+}
+function validateFile(value, control) {
+  if (!control.file) {
+    return { valid: true };
+  }
+  const files = Array.isArray(value) ? value : [value];
+  if (control.file.maxFiles && files.length > control.file.maxFiles) {
+    return {
+      valid: false,
+      error: `Maximum ${control.file.maxFiles} files allowed`
+    };
+  }
+  for (const file of files) {
+    if (!file || typeof file !== "object") continue;
+    const fileObj = file;
+    if (control.file.maxSize && fileObj.size && fileObj.size > control.file.maxSize) {
+      return {
+        valid: false,
+        error: `File size exceeds maximum of ${formatBytes(control.file.maxSize)}`
+      };
+    }
+    if (control.file.accept && fileObj.mimeType) {
+      const accepted = control.file.accept.some(
+        (pattern) => matchesMimeType(fileObj.mimeType, pattern)
+      );
+      if (!accepted) {
+        return {
+          valid: false,
+          error: `File type ${fileObj.mimeType} is not accepted`
+        };
+      }
+    }
+  }
+  return { valid: true };
+}
+function matchesMimeType(mimeType, pattern) {
+  if (pattern === "*/*") return true;
+  if (pattern.endsWith("/*")) {
+    const prefix = pattern.slice(0, -1);
+    return mimeType.startsWith(prefix);
+  }
+  return mimeType === pattern;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function parseValue(value, control) {
+  const handler = typeHandlers.get(control.type);
+  if (handler?.parse) {
+    return handler.parse(value);
+  }
+  switch (control.type) {
+    case "number":
+      return parseFloat(value.replace(/[,$]/g, ""));
+    case "boolean": {
+      const lower = value.toLowerCase();
+      return ["true", "yes", "1", "on"].includes(lower);
+    }
+    case "date": {
+      const timestamp = Date.parse(value);
+      return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : value;
+    }
+    default:
+      return value;
+  }
+}
+function formatValue(value, control) {
+  if (value === void 0 || value === null) return "";
+  const handler = typeHandlers.get(control.type);
+  if (handler?.format) {
+    return handler.format(value);
+  }
+  if (control.sensitive) {
+    const strVal = String(value);
+    if (strVal.length > 8) {
+      return `${strVal.slice(0, 4)}...${strVal.slice(-4)}`;
+    }
+    return "****";
+  }
+  switch (control.type) {
+    case "number":
+      return typeof value === "number" ? value.toLocaleString() : String(value);
+    case "boolean":
+      return value ? "Yes" : "No";
+    case "date":
+      return value instanceof Date ? value.toLocaleDateString() : String(value);
+    case "select":
+      if (control.options) {
+        const option = control.options.find((opt) => opt.value === String(value));
+        if (option) return option.label;
+      }
+      return String(value);
+    case "file":
+      if (Array.isArray(value)) {
+        return value.map((f) => f.name || "file").join(", ");
+      }
+      return value.name || "file";
+    default:
+      return String(value);
+  }
+}
+
+export {
+  registerTypeHandler,
+  getTypeHandler,
+  clearTypeHandlers,
+  validateField,
+  matchesMimeType,
+  parseValue,
+  formatValue
+};