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

package/dist/index.js

@@ -1,2661 +1,64 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// src/types.ts
-var FORM_CONTROL_DEFAULTS, FORM_DEFINITION_DEFAULTS, FORM_SESSION_COMPONENT = "form_session", FORM_SUBMISSION_COMPONENT = "form_submission", FORM_AUTOFILL_COMPONENT = "form_autofill";
-var init_types = __esm(() => {
-  FORM_CONTROL_DEFAULTS = {
-    type: "text",
-    required: false,
-    confirmThreshold: 0.8
-  };
-  FORM_DEFINITION_DEFAULTS = {
-    version: 1,
-    status: "active",
-    ux: {
-      allowUndo: true,
-      allowSkip: true,
-      maxUndoSteps: 5,
-      showExamples: true,
-      showExplanations: true,
-      allowAutofill: true
-    },
-    ttl: {
-      minDays: 14,
-      maxDays: 90,
-      effortMultiplier: 0.5
-    },
-    nudge: {
-      enabled: true,
-      afterInactiveHours: 48,
-      maxNudges: 3
-    },
-    debug: false
-  };
-});
-
-// src/builtins.ts
-function registerBuiltinTypes(registerFn) {
-  for (const type of BUILTIN_TYPES) {
-    registerFn(type);
-  }
-}
-function getBuiltinType(id) {
-  return BUILTIN_TYPE_MAP.get(id);
-}
-function isBuiltinType(id) {
-  return BUILTIN_TYPE_MAP.has(id);
-}
-var EMAIL_REGEX, ISO_DATE_REGEX, textType, numberType, emailType, booleanType, selectType, dateType, fileType, BUILTIN_TYPES, BUILTIN_TYPE_MAP;
-var init_builtins = __esm(() => {
-  EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
-  textType = {
-    id: "text",
-    builtin: true,
-    validate: (value, control) => {
-      if (value === null || value === undefined) {
-        return { valid: true };
-      }
-      const str = String(value);
-      if (control.minLength !== undefined && str.length < control.minLength) {
-        return {
-          valid: false,
-          error: `Must be at least ${control.minLength} characters`
-        };
-      }
-      if (control.maxLength !== undefined && str.length > control.maxLength) {
-        return {
-          valid: false,
-          error: `Must be at most ${control.maxLength} characters`
-        };
-      }
-      if (control.pattern) {
-        const regex = new RegExp(control.pattern);
-        if (!regex.test(str)) {
-          return { valid: false, error: "Invalid format" };
-        }
-      }
-      if (control.enum && !control.enum.includes(str)) {
-        return {
-          valid: false,
-          error: `Must be one of: ${control.enum.join(", ")}`
-        };
-      }
-      return { valid: true };
-    },
-    parse: (value) => String(value).trim(),
-    format: (value) => String(value ?? ""),
-    extractionPrompt: "a text string"
-  };
-  numberType = {
-    id: "number",
-    builtin: true,
-    validate: (value, control) => {
-      if (value === null || value === undefined || value === "") {
-        return { valid: true };
-      }
-      const num = typeof value === "number" ? value : parseFloat(String(value));
-      if (Number.isNaN(num)) {
-        return { valid: false, error: "Must be a valid number" };
-      }
-      if (control.min !== undefined && num < control.min) {
-        return { valid: false, error: `Must be at least ${control.min}` };
-      }
-      if (control.max !== undefined && num > control.max) {
-        return { valid: false, error: `Must be at most ${control.max}` };
-      }
-      return { valid: true };
-    },
-    parse: (value) => {
-      const cleaned = value.replace(/[,$\s]/g, "");
-      return parseFloat(cleaned);
-    },
-    format: (value) => {
-      if (value === null || value === undefined)
-        return "";
-      const num = typeof value === "number" ? value : parseFloat(String(value));
-      if (Number.isNaN(num))
-        return String(value);
-      return num.toLocaleString();
-    },
-    extractionPrompt: "a number (integer or decimal)"
-  };
-  emailType = {
-    id: "email",
-    builtin: true,
-    validate: (value) => {
-      if (value === null || value === undefined || value === "") {
-        return { valid: true };
-      }
-      const str = String(value).trim().toLowerCase();
-      if (!EMAIL_REGEX.test(str)) {
-        return { valid: false, error: "Invalid email format" };
-      }
-      return { valid: true };
-    },
-    parse: (value) => value.trim().toLowerCase(),
-    format: (value) => String(value ?? "").toLowerCase(),
-    extractionPrompt: "an email address (e.g., user@example.com)"
-  };
-  booleanType = {
-    id: "boolean",
-    builtin: true,
-    validate: (value) => {
-      if (value === null || value === undefined) {
-        return { valid: true };
-      }
-      if (typeof value === "boolean") {
-        return { valid: true };
-      }
-      const str = String(value).toLowerCase();
-      const validValues = ["true", "false", "yes", "no", "1", "0", "on", "off"];
-      if (!validValues.includes(str)) {
-        return { valid: false, error: "Must be yes/no or true/false" };
-      }
-      return { valid: true };
-    },
-    parse: (value) => {
-      const str = value.toLowerCase();
-      return ["true", "yes", "1", "on"].includes(str);
-    },
-    format: (value) => {
-      if (value === true)
-        return "Yes";
-      if (value === false)
-        return "No";
-      return String(value ?? "");
-    },
-    extractionPrompt: "a yes/no or true/false value"
-  };
-  selectType = {
-    id: "select",
-    builtin: true,
-    validate: (value, control) => {
-      if (value === null || value === undefined || value === "") {
-        return { valid: true };
-      }
-      const str = String(value);
-      if (control.options) {
-        const validValues = control.options.map((o) => o.value);
-        if (!validValues.includes(str)) {
-          const labels = control.options.map((o) => o.label).join(", ");
-          return { valid: false, error: `Must be one of: ${labels}` };
-        }
-      }
-      if (control.enum && !control.options) {
-        if (!control.enum.includes(str)) {
-          return {
-            valid: false,
-            error: `Must be one of: ${control.enum.join(", ")}`
-          };
-        }
-      }
-      return { valid: true };
-    },
-    parse: (value) => value.trim(),
-    format: (value) => String(value ?? ""),
-    extractionPrompt: "one of the available options"
-  };
-  dateType = {
-    id: "date",
-    builtin: true,
-    validate: (value) => {
-      if (value === null || value === undefined || value === "") {
-        return { valid: true };
-      }
-      const str = String(value);
-      if (!ISO_DATE_REGEX.test(str)) {
-        return { valid: false, error: "Must be in YYYY-MM-DD format" };
-      }
-      const date = new Date(str);
-      if (Number.isNaN(date.getTime())) {
-        return { valid: false, error: "Invalid date" };
-      }
-      return { valid: true };
-    },
-    parse: (value) => {
-      const date = new Date(value);
-      if (!Number.isNaN(date.getTime())) {
-        return date.toISOString().split("T")[0];
-      }
-      return value.trim();
-    },
-    format: (value) => {
-      if (!value)
-        return "";
-      const date = new Date(String(value));
-      if (Number.isNaN(date.getTime()))
-        return String(value);
-      return date.toLocaleDateString();
-    },
-    extractionPrompt: "a date (preferably in YYYY-MM-DD format)"
-  };
-  fileType = {
-    id: "file",
-    builtin: true,
-    validate: (value, _control) => {
-      if (value === null || value === undefined) {
-        return { valid: true };
-      }
-      if (typeof value === "object") {
-        return { valid: true };
-      }
-      return { valid: false, error: "Invalid file data" };
-    },
-    format: (value) => {
-      if (!value)
-        return "";
-      if (Array.isArray(value)) {
-        return `${value.length} file(s)`;
-      }
-      if (typeof value === "object" && value !== null && "name" in value) {
-        return String(value.name);
-      }
-      return "File attached";
-    },
-    extractionPrompt: "a file attachment (upload required)"
-  };
-  BUILTIN_TYPES = [
-    textType,
-    numberType,
-    emailType,
-    booleanType,
-    selectType,
-    dateType,
-    fileType
-  ];
-  BUILTIN_TYPE_MAP = new Map(BUILTIN_TYPES.map((t) => [t.id, t]));
-});
-
-// src/validation.ts
-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 === undefined || value === null || value === "") {
-      return {
-        valid: false,
-        error: `${control.label || control.key} is required`
-      };
-    }
-  }
-  if (value === undefined || 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 !== undefined && strValue.length < control.minLength) {
-    return {
-      valid: false,
-      error: `${control.label || control.key} must be at least ${control.minLength} characters`
-    };
-  }
-  if (control.maxLength !== undefined && 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 !== undefined && numValue < control.min) {
-    return {
-      valid: false,
-      error: `${control.label || control.key} must be at least ${control.min}`
-    };
-  }
-  if (control.max !== undefined && 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 !== undefined && dateValue.getTime() < control.min) {
-    return {
-      valid: false,
-      error: `${control.label || control.key} is too early`
-    };
-  }
-  if (control.max !== undefined && 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 === undefined || 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);
-  }
-}
-var typeHandlers;
-var init_validation = __esm(() => {
-  typeHandlers = new Map;
-});
-
-// src/intent.ts
-function quickIntentDetect(text) {
-  const lower = text.toLowerCase().trim();
-  if (lower.length < 2) {
-    return null;
-  }
-  if (/\b(resume|continue|pick up where|go back to|get back to)\b/.test(lower)) {
-    return "restore";
-  }
-  if (/\b(submit|done|finish|send it|that'?s all|i'?m done|complete|all set)\b/.test(lower)) {
-    return "submit";
-  }
-  if (/\b(save|stash|later|hold on|pause|save for later|come back|save this)\b/.test(lower)) {
-    if (!/\b(save and submit|save and send)\b/.test(lower)) {
-      return "stash";
-    }
-  }
-  if (/\b(cancel|abort|nevermind|never mind|forget it|stop|quit|exit)\b/.test(lower)) {
-    return "cancel";
-  }
-  if (/\b(undo|go back|wait no|change that|oops|that'?s wrong|wrong|not right)\b/.test(lower)) {
-    return "undo";
-  }
-  if (/\b(skip|pass|don'?t know|next one|next|don'?t have|no idea)\b/.test(lower)) {
-    if (!/\bskip to\b/.test(lower)) {
-      return "skip";
-    }
-  }
-  if (/\b(why|what'?s that for|explain|what do you mean|what is|purpose|reason)\b\??$/i.test(lower)) {
-    return "explain";
-  }
-  if (/^why\??$/i.test(lower)) {
-    return "explain";
-  }
-  if (/\b(example|like what|show me|such as|for instance|sample)\b\??$/i.test(lower)) {
-    return "example";
-  }
-  if (/^(example|e\.?g\.?)\??$/i.test(lower)) {
-    return "example";
-  }
-  if (/\b(how far|how many left|progress|status|how much more|where are we)\b/.test(lower)) {
-    return "progress";
-  }
-  if (/\b(same as|last time|use my usual|like before|previous|from before)\b/.test(lower)) {
-    return "autofill";
-  }
-  return null;
-}
-function isLifecycleIntent(intent) {
-  return ["submit", "stash", "restore", "cancel"].includes(intent);
-}
-function isUXIntent(intent) {
-  return ["undo", "skip", "explain", "example", "progress", "autofill"].includes(intent);
-}
-function hasDataToExtract(intent) {
-  return intent === "fill_form" || intent === "other";
-}
-
-// node_modules/uuid/dist-node/stringify.js
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-var byteToHex;
-var init_stringify = __esm(() => {
-  byteToHex = [];
-  for (let i = 0;i < 256; ++i) {
-    byteToHex.push((i + 256).toString(16).slice(1));
-  }
-});
-
-// node_modules/uuid/dist-node/rng.js
-import { randomFillSync } from "node:crypto";
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-var rnds8Pool, poolPtr;
-var init_rng = __esm(() => {
-  rnds8Pool = new Uint8Array(256);
-  poolPtr = rnds8Pool.length;
-});
-
-// node_modules/uuid/dist-node/native.js
-import { randomUUID } from "node:crypto";
-var native_default;
-var init_native = __esm(() => {
-  native_default = { randomUUID };
-});
-
-// node_modules/uuid/dist-node/v4.js
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0;i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-var v4_default;
-var init_v4 = __esm(() => {
-  init_native();
-  init_rng();
-  init_stringify();
-  v4_default = v4;
-});
-
-// node_modules/uuid/dist-node/index.js
-var init_dist_node = __esm(() => {
-  init_v4();
-});
-
-// src/storage.ts
-async function getActiveSession(runtime, entityId, roomId) {
-  const component = await runtime.getComponent(entityId, `${FORM_SESSION_COMPONENT}:${roomId}`);
-  if (!component?.data || !isFormSession(component.data))
-    return null;
-  const session = component.data;
-  if (session.status === "active" || session.status === "ready") {
-    return session;
-  }
-  return null;
-}
-async function getAllActiveSessions(runtime, entityId) {
-  const components = await runtime.getComponents(entityId);
-  const sessions = [];
-  for (const component of components) {
-    if (component.type.startsWith(`${FORM_SESSION_COMPONENT}:`)) {
-      if (component.data && isFormSession(component.data)) {
-        const session = component.data;
-        if (session.status === "active" || session.status === "ready") {
-          sessions.push(session);
-        }
-      }
-    }
-  }
-  return sessions;
-}
-async function getStashedSessions(runtime, entityId) {
-  const components = await runtime.getComponents(entityId);
-  const sessions = [];
-  for (const component of components) {
-    if (component.type.startsWith(`${FORM_SESSION_COMPONENT}:`)) {
-      if (component.data && isFormSession(component.data)) {
-        const session = component.data;
-        if (session.status === "stashed") {
-          sessions.push(session);
-        }
-      }
-    }
-  }
-  return sessions;
-}
-async function getSessionById(runtime, entityId, sessionId) {
-  const components = await runtime.getComponents(entityId);
-  for (const component of components) {
-    if (component.type.startsWith(`${FORM_SESSION_COMPONENT}:`)) {
-      if (component.data && isFormSession(component.data)) {
-        const session = component.data;
-        if (session.id === sessionId) {
-          return session;
-        }
-      }
-    }
-  }
-  return null;
-}
-async function saveSession(runtime, session) {
-  const componentType = `${FORM_SESSION_COMPONENT}:${session.roomId}`;
-  const existing = await runtime.getComponent(session.entityId, componentType);
-  const context = await resolveComponentContext(runtime, session.roomId);
-  const resolvedWorldId = existing?.worldId ?? context.worldId;
-  const component = {
-    id: existing?.id || v4_default(),
-    entityId: session.entityId,
-    agentId: runtime.agentId,
-    roomId: session.roomId,
-    worldId: resolvedWorldId,
-    sourceEntityId: runtime.agentId,
-    type: componentType,
-    createdAt: existing?.createdAt || Date.now(),
-    data: JSON.parse(JSON.stringify(session))
-  };
-  if (existing) {
-    await runtime.updateComponent(component);
-  } else {
-    await runtime.createComponent(component);
-  }
-}
-async function deleteSession(runtime, session) {
-  const componentType = `${FORM_SESSION_COMPONENT}:${session.roomId}`;
-  const existing = await runtime.getComponent(session.entityId, componentType);
-  if (existing) {
-    await runtime.deleteComponent(existing.id);
-  }
-}
-async function saveSubmission(runtime, submission) {
-  const componentType = `${FORM_SUBMISSION_COMPONENT}:${submission.formId}:${submission.id}`;
-  const context = await resolveComponentContext(runtime);
-  const component = {
-    id: v4_default(),
-    entityId: submission.entityId,
-    agentId: runtime.agentId,
-    roomId: context.roomId,
-    worldId: context.worldId,
-    sourceEntityId: runtime.agentId,
-    type: componentType,
-    createdAt: submission.submittedAt,
-    data: JSON.parse(JSON.stringify(submission))
-  };
-  await runtime.createComponent(component);
-}
-async function getSubmissions(runtime, entityId, formId) {
-  const components = await runtime.getComponents(entityId);
-  const submissions = [];
-  const prefix = formId ? `${FORM_SUBMISSION_COMPONENT}:${formId}:` : `${FORM_SUBMISSION_COMPONENT}:`;
-  for (const component of components) {
-    if (component.type.startsWith(prefix)) {
-      if (component.data && isFormSubmission(component.data)) {
-        submissions.push(component.data);
-      }
-    }
-  }
-  submissions.sort((a, b) => b.submittedAt - a.submittedAt);
-  return submissions;
-}
-async function getAutofillData(runtime, entityId, formId) {
-  const componentType = `${FORM_AUTOFILL_COMPONENT}:${formId}`;
-  const component = await runtime.getComponent(entityId, componentType);
-  if (!component?.data || !isFormAutofillData(component.data))
-    return null;
-  return component.data;
-}
-async function saveAutofillData(runtime, entityId, formId, values) {
-  const componentType = `${FORM_AUTOFILL_COMPONENT}:${formId}`;
-  const existing = await runtime.getComponent(entityId, componentType);
-  const context = await resolveComponentContext(runtime);
-  const resolvedWorldId = existing?.worldId ?? context.worldId;
-  const data = {
-    formId,
-    values,
-    updatedAt: Date.now()
-  };
-  const component = {
-    id: existing?.id || v4_default(),
-    entityId,
-    agentId: runtime.agentId,
-    roomId: context.roomId,
-    worldId: resolvedWorldId,
-    sourceEntityId: runtime.agentId,
-    type: componentType,
-    createdAt: existing?.createdAt || Date.now(),
-    data: JSON.parse(JSON.stringify(data))
-  };
-  if (existing) {
-    await runtime.updateComponent(component);
-  } else {
-    await runtime.createComponent(component);
-  }
-}
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), resolveComponentContext = async (runtime, roomId) => {
-  if (roomId) {
-    const room = await runtime.getRoom(roomId);
-    return { roomId, worldId: room?.worldId ?? runtime.agentId };
-  }
-  return { roomId: runtime.agentId, worldId: runtime.agentId };
-}, isFormSession = (data) => {
-  if (!isRecord(data))
-    return false;
-  return typeof data.id === "string" && typeof data.formId === "string" && typeof data.entityId === "string" && typeof data.roomId === "string";
-}, isFormSubmission = (data) => {
-  if (!isRecord(data))
-    return false;
-  return typeof data.id === "string" && typeof data.formId === "string" && typeof data.sessionId === "string" && typeof data.entityId === "string";
-}, isFormAutofillData = (data) => {
-  if (!isRecord(data))
-    return false;
-  return typeof data.formId === "string" && typeof data.updatedAt === "number" && typeof data.values === "object";
-};
-var init_storage = __esm(() => {
-  init_dist_node();
-  init_types();
-});
-
-// src/template.ts
-function buildTemplateValues(session) {
-  const values = {};
-  for (const [key, state] of Object.entries(session.fields)) {
-    const value = state.value;
-    if (typeof value === "string") {
-      values[key] = value;
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      values[key] = String(value);
-    }
-  }
-  const context = session.context;
-  if (context && typeof context === "object" && !Array.isArray(context)) {
-    for (const [key, value] of Object.entries(context)) {
-      if (typeof value === "string") {
-        values[key] = value;
-      } else if (typeof value === "number" || typeof value === "boolean") {
-        values[key] = String(value);
-      }
-    }
-  }
-  return values;
-}
-function renderTemplate(template, values) {
-  if (!template) {
-    return template;
-  }
-  return template.replace(TEMPLATE_PATTERN, (match, key) => {
-    const replacement = values[key];
-    return replacement !== undefined ? replacement : match;
-  });
-}
-function resolveControlTemplates(control, values) {
-  const resolvedOptions = control.options?.map((option) => ({
-    ...option,
-    label: renderTemplate(option.label, values) ?? option.label,
-    description: renderTemplate(option.description, values)
-  }));
-  const resolvedFields = control.fields?.map((field) => resolveControlTemplates(field, values));
-  return {
-    ...control,
-    label: renderTemplate(control.label, values) ?? control.label,
-    description: renderTemplate(control.description, values),
-    askPrompt: renderTemplate(control.askPrompt, values),
-    example: renderTemplate(control.example, values),
-    extractHints: control.extractHints?.map((hint) => renderTemplate(hint, values) ?? hint),
-    options: resolvedOptions,
-    fields: resolvedFields ?? control.fields
-  };
-}
-var TEMPLATE_PATTERN;
-var init_template = __esm(() => {
-  TEMPLATE_PATTERN = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
-});
-
-// src/extraction.ts
-import { ModelType, parseKeyValueXml } from "@elizaos/core";
-async function llmIntentAndExtract(runtime, text, form, controls, templateValues) {
-  const resolvedControls = templateValues ? controls.map((control) => resolveControlTemplates(control, templateValues)) : controls;
-  const fieldsDescription = resolvedControls.filter((c) => !c.hidden).map((c) => {
-    const handler = getTypeHandler(c.type);
-    const typeHint = handler?.extractionPrompt || c.type;
-    const hints = c.extractHints?.join(", ") || "";
-    const options = c.options?.map((o) => o.value).join(", ") || "";
-    return `- ${c.key} (${c.label}): ${c.description || typeHint}${hints ? ` [hints: ${hints}]` : ""}${options ? ` [options: ${options}]` : ""}`;
-  }).join(`
-`);
-  const prompt = `You are extracting structured data from a user's natural language message.
-
-FORM: ${form.name}
-${form.description ? `DESCRIPTION: ${form.description}` : ""}
-
-FIELDS TO EXTRACT:
-${fieldsDescription}
-
-USER MESSAGE:
-"${text}"
-
-INSTRUCTIONS:
-1. Determine the user's intent:
-   - fill_form: They are providing information for form fields
-   - submit: They want to submit/complete the form ("done", "submit", "finish", "that's all")
-   - stash: They want to save for later ("save for later", "pause", "hold on")
-   - restore: They want to resume a saved form ("resume", "continue", "pick up where")
-   - cancel: They want to cancel ("cancel", "abort", "nevermind", "forget it")
-   - undo: They want to undo last change ("undo", "go back", "wait no")
-   - skip: They want to skip current field ("skip", "pass", "don't know")
-   - explain: They want explanation ("why?", "what's that for?")
-   - example: They want an example ("example?", "like what?")
-   - progress: They want progress update ("how far?", "status")
-   - autofill: They want to use saved values ("same as last time")
-   - other: None of the above
-
-2. For fill_form intent, extract all field values mentioned.
-   - For each extracted value, provide a confidence score (0.0-1.0)
-   - Note if this appears to be a correction to a previous value
-
-Respond in this exact XML format:
-<response>
-  <intent>fill_form|submit|stash|restore|cancel|undo|skip|explain|example|progress|autofill|other</intent>
-  <extractions>
-    <field>
-      <key>field_key</key>
-      <value>extracted_value</value>
-      <confidence>0.0-1.0</confidence>
-      <reasoning>why this value was extracted</reasoning>
-      <is_correction>true|false</is_correction>
-    </field>
-    <!-- more fields if applicable -->
-  </extractions>
-</response>`;
-  try {
-    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt,
-      temperature: 0.1
-    });
-    const parsed = parseExtractionResponse(response);
-    for (const extraction of parsed.extractions) {
-      const control = resolvedControls.find((c) => c.key === extraction.field);
-      if (control) {
-        if (typeof extraction.value === "string") {
-          extraction.value = parseValue(extraction.value, control);
-        }
-        const validation = validateField(extraction.value, control);
-        if (!validation.valid) {
-          extraction.confidence = Math.min(extraction.confidence, 0.3);
-          extraction.reasoning = `${extraction.reasoning || ""} (Validation failed: ${validation.error})`;
-        }
-      }
-    }
-    if (form.debug) {
-      runtime.logger.debug("[FormExtraction] LLM extraction result:", JSON.stringify(parsed));
-    }
-    return parsed;
-  } catch (error) {
-    runtime.logger.error("[FormExtraction] LLM extraction failed:", String(error));
-    return { intent: "other", extractions: [] };
-  }
-}
-function parseExtractionResponse(response) {
-  const result = {
-    intent: "other",
-    extractions: []
-  };
-  try {
-    const parsed = parseKeyValueXml(response);
-    if (parsed) {
-      const intentStr = parsed.intent?.toLowerCase() ?? "other";
-      result.intent = isValidIntent(intentStr) ? intentStr : "other";
-      if (parsed.extractions) {
-        const fields = Array.isArray(parsed.extractions) ? parsed.extractions : parsed.extractions.field ? Array.isArray(parsed.extractions.field) ? parsed.extractions.field : [parsed.extractions.field] : [];
-        for (const field of fields) {
-          if (field?.key) {
-            const extraction = {
-              field: String(field.key),
-              value: field.value ?? null,
-              confidence: parseFloat(String(field.confidence ?? "")) || 0.5,
-              reasoning: field.reasoning ? String(field.reasoning) : undefined,
-              isCorrection: field.is_correction === "true" || field.is_correction === true
-            };
-            result.extractions.push(extraction);
-          }
-        }
-      }
-    }
-  } catch (_error) {
-    const intentMatch = response.match(/<intent>([^<]+)<\/intent>/);
-    if (intentMatch) {
-      const intentStr = intentMatch[1].toLowerCase().trim();
-      result.intent = isValidIntent(intentStr) ? intentStr : "other";
-    }
-    const fieldMatches = response.matchAll(/<field>\s*<key>([^<]+)<\/key>\s*<value>([^<]*)<\/value>\s*<confidence>([^<]+)<\/confidence>/g);
-    for (const match of fieldMatches) {
-      result.extractions.push({
-        field: match[1].trim(),
-        value: match[2].trim(),
-        confidence: parseFloat(match[3]) || 0.5
-      });
-    }
-  }
-  return result;
-}
-function isValidIntent(str) {
-  const validIntents = [
-    "fill_form",
-    "submit",
-    "stash",
-    "restore",
-    "cancel",
-    "undo",
-    "skip",
-    "explain",
-    "example",
-    "progress",
-    "autofill",
-    "other"
-  ];
-  return validIntents.includes(str);
-}
-async function extractSingleField(runtime, text, control, debug, templateValues) {
-  const resolvedControl = templateValues ? resolveControlTemplates(control, templateValues) : control;
-  const handler = getTypeHandler(resolvedControl.type);
-  const typeHint = handler?.extractionPrompt || resolvedControl.type;
-  const prompt = `Extract the ${resolvedControl.label} (${typeHint}) from this message:
-
-"${text}"
-
-${resolvedControl.description ? `Context: ${resolvedControl.description}` : ""}
-${resolvedControl.extractHints?.length ? `Look for: ${resolvedControl.extractHints.join(", ")}` : ""}
-${resolvedControl.options?.length ? `Valid options: ${resolvedControl.options.map((o) => o.value).join(", ")}` : ""}
-${resolvedControl.example ? `Example: ${resolvedControl.example}` : ""}
-
-Respond in XML:
-<response>
-  <found>true|false</found>
-  <value>extracted_value or empty if not found</value>
-  <confidence>0.0-1.0</confidence>
-  <reasoning>brief explanation</reasoning>
-</response>`;
-  try {
-    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt,
-      temperature: 0.1
-    });
-    const parsed = parseKeyValueXml(response);
-    const found = parsed?.found === true || parsed?.found === "true";
-    if (found) {
-      let value = parsed.value;
-      if (typeof value === "string") {
-        value = parseValue(value, resolvedControl);
-      }
-      const confidence = typeof parsed?.confidence === "number" ? parsed.confidence : parseFloat(String(parsed?.confidence ?? ""));
-      const result = {
-        field: resolvedControl.key,
-        value: value ?? null,
-        confidence: Number.isFinite(confidence) ? confidence : 0.5,
-        reasoning: parsed.reasoning ? String(parsed.reasoning) : undefined
-      };
-      if (debug) {
-        runtime.logger.debug("[FormExtraction] Single field extraction:", JSON.stringify(result));
-      }
-      return result;
-    }
-    return null;
-  } catch (error) {
-    runtime.logger.error("[FormExtraction] Single field extraction failed:", String(error));
-    return null;
-  }
-}
-async function detectCorrection(runtime, text, currentValues, controls, templateValues) {
-  const resolvedControls = templateValues ? controls.map((control) => resolveControlTemplates(control, templateValues)) : controls;
-  const currentValuesStr = resolvedControls.filter((c) => currentValues[c.key] !== undefined).map((c) => `- ${c.label}: ${currentValues[c.key]}`).join(`
-`);
-  if (!currentValuesStr) {
-    return [];
-  }
-  const prompt = `Is the user correcting any of these previously provided values?
-
-Current values:
-${currentValuesStr}
-
-User message:
-"${text}"
-
-If they are correcting a value, extract the new value. Otherwise respond with no corrections.
-
-Respond in XML:
-<response>
-  <has_correction>true|false</has_correction>
-  <corrections>
-    <correction>
-      <field>field_label</field>
-      <old_value>previous value</old_value>
-      <new_value>corrected value</new_value>
-      <confidence>0.0-1.0</confidence>
-    </correction>
-  </corrections>
-</response>`;
-  try {
-    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt,
-      temperature: 0.1
-    });
-    const parsed = parseKeyValueXml(response);
-    const hasCorrection = parsed?.has_correction === true || parsed?.has_correction === "true";
-    if (parsed && hasCorrection && parsed.corrections) {
-      const corrections = [];
-      const correctionList = Array.isArray(parsed.corrections) ? parsed.corrections : parsed.corrections.correction ? Array.isArray(parsed.corrections.correction) ? parsed.corrections.correction : [parsed.corrections.correction] : [];
-      for (const correction of correctionList) {
-        const fieldName = correction.field ? String(correction.field) : "";
-        const control = resolvedControls.find((c) => c.label.toLowerCase() === fieldName.toLowerCase() || c.key.toLowerCase() === fieldName.toLowerCase());
-        if (control) {
-          let value = correction.new_value;
-          if (typeof value === "string") {
-            value = parseValue(value, control);
-          }
-          const confidence = typeof correction.confidence === "number" ? correction.confidence : parseFloat(String(correction.confidence ?? ""));
-          const extraction = {
-            field: control.key,
-            value: value ?? null,
-            confidence: Number.isFinite(confidence) ? confidence : 0.8,
-            isCorrection: true
-          };
-          corrections.push(extraction);
-        }
-      }
-      return corrections;
-    }
-    return [];
-  } catch (error) {
-    runtime.logger.error("[FormExtraction] Correction detection failed:", String(error));
-    return [];
-  }
-}
-var init_extraction = __esm(() => {
-  init_template();
-  init_validation();
-});
-
-// src/service.ts
-var exports_service = {};
-__export(exports_service, {
-  FormService: () => FormService
-});
-import {
-  logger,
-  Service
-} from "@elizaos/core";
-function prettify3(key) {
-  return key.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-var FormService;
-var init_service = __esm(() => {
-  init_dist_node();
-  init_builtins();
-  init_storage();
-  init_types();
-  init_validation();
-  FormService = class FormService extends Service {
-    static serviceType = "FORM";
-    capabilityDescription = "Manages conversational forms for data collection";
-    forms = new Map;
-    controlTypes = new Map;
-    static async start(runtime) {
-      const service = new FormService(runtime);
-      registerBuiltinTypes((type, options) => service.registerControlType(type, options));
-      logger.info("[FormService] Started with built-in types");
-      return service;
-    }
-    async stop() {
-      logger.info("[FormService] Stopped");
-    }
-    registerForm(definition) {
-      const form = {
-        ...definition,
-        version: definition.version ?? FORM_DEFINITION_DEFAULTS.version,
-        status: definition.status ?? FORM_DEFINITION_DEFAULTS.status,
-        ux: { ...FORM_DEFINITION_DEFAULTS.ux, ...definition.ux },
-        ttl: { ...FORM_DEFINITION_DEFAULTS.ttl, ...definition.ttl },
-        nudge: { ...FORM_DEFINITION_DEFAULTS.nudge, ...definition.nudge },
-        debug: definition.debug ?? FORM_DEFINITION_DEFAULTS.debug,
-        controls: definition.controls.map((control) => ({
-          ...control,
-          type: control.type || FORM_CONTROL_DEFAULTS.type,
-          required: control.required ?? FORM_CONTROL_DEFAULTS.required,
-          confirmThreshold: control.confirmThreshold ?? FORM_CONTROL_DEFAULTS.confirmThreshold,
-          label: control.label || prettify3(control.key)
-        }))
-      };
-      this.forms.set(form.id, form);
-      logger.debug(`[FormService] Registered form: ${form.id}`);
-    }
-    getForm(formId) {
-      return this.forms.get(formId);
-    }
-    listForms() {
-      return Array.from(this.forms.values());
-    }
-    registerControlType(type, options) {
-      const existing = this.controlTypes.get(type.id);
-      if (existing) {
-        if (existing.builtin && !options?.allowOverride) {
-          logger.warn(`[FormService] Cannot override builtin type '${type.id}' without allowOverride: true`);
-          return;
-        }
-        logger.warn(`[FormService] Overriding control type: ${type.id}`);
-      }
-      this.controlTypes.set(type.id, type);
-      logger.debug(`[FormService] Registered control type: ${type.id}`);
-    }
-    getControlType(typeId) {
-      return this.controlTypes.get(typeId);
-    }
-    listControlTypes() {
-      return Array.from(this.controlTypes.values());
-    }
-    isCompositeType(typeId) {
-      const type = this.controlTypes.get(typeId);
-      return !!type?.getSubControls;
-    }
-    isExternalType(typeId) {
-      const type = this.controlTypes.get(typeId);
-      return !!type?.activate;
-    }
-    getSubControls(control) {
-      const type = this.controlTypes.get(control.type);
-      if (!type?.getSubControls) {
-        return [];
-      }
-      return type.getSubControls(control, this.runtime);
-    }
-    async startSession(formId, entityId, roomId, options) {
-      const form = this.getForm(formId);
-      if (!form) {
-        throw new Error(`Form not found: ${formId}`);
-      }
-      const existing = await getActiveSession(this.runtime, entityId, roomId);
-      if (existing) {
-        throw new Error(`Active session already exists for this user/room: ${existing.id}`);
-      }
-      const now = Date.now();
-      const fields = {};
-      for (const control of form.controls) {
-        if (options?.initialValues?.[control.key] !== undefined) {
-          fields[control.key] = {
-            status: "filled",
-            value: options.initialValues[control.key],
-            source: "manual",
-            updatedAt: now
-          };
-        } else if (control.defaultValue !== undefined) {
-          fields[control.key] = {
-            status: "filled",
-            value: control.defaultValue,
-            source: "default",
-            updatedAt: now
-          };
-        } else {
-          fields[control.key] = { status: "empty" };
-        }
-      }
-      const ttlDays = form.ttl?.minDays ?? 14;
-      const expiresAt = now + ttlDays * 24 * 60 * 60 * 1000;
-      const session = {
-        id: v4_default(),
-        formId,
-        formVersion: form.version,
-        entityId,
-        roomId,
-        status: "active",
-        fields,
-        history: [],
-        context: options?.context,
-        locale: options?.locale,
-        effort: {
-          interactionCount: 0,
-          timeSpentMs: 0,
-          firstInteractionAt: now,
-          lastInteractionAt: now
-        },
-        expiresAt,
-        createdAt: now,
-        updatedAt: now
-      };
-      await saveSession(this.runtime, session);
-      if (form.hooks?.onStart) {
-        await this.executeHook(session, "onStart");
-      }
-      logger.debug(`[FormService] Started session ${session.id} for form ${formId}`);
-      return session;
-    }
-    async getActiveSession(entityId, roomId) {
-      return getActiveSession(this.runtime, entityId, roomId);
-    }
-    async getAllActiveSessions(entityId) {
-      return getAllActiveSessions(this.runtime, entityId);
-    }
-    async getStashedSessions(entityId) {
-      return getStashedSessions(this.runtime, entityId);
-    }
-    async saveSession(session) {
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-    }
-    async updateField(sessionId, entityId, field, value, confidence, source, messageId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form) {
-        throw new Error(`Form not found: ${session.formId}`);
-      }
-      const control = form.controls.find((c) => c.key === field);
-      if (!control) {
-        throw new Error(`Field not found: ${field}`);
-      }
-      const oldValue = session.fields[field]?.value;
-      const validation = validateField(value, control);
-      let status;
-      if (!validation.valid) {
-        status = "invalid";
-      } else if (confidence < (control.confirmThreshold ?? 0.8)) {
-        status = "uncertain";
-      } else {
-        status = "filled";
-      }
-      const now = Date.now();
-      if (oldValue !== undefined) {
-        const historyEntry = {
-          field,
-          oldValue,
-          newValue: value,
-          timestamp: now
-        };
-        session.history.push(historyEntry);
-        const maxUndo = form.ux?.maxUndoSteps ?? 5;
-        if (session.history.length > maxUndo) {
-          session.history = session.history.slice(-maxUndo);
-        }
-      }
-      session.fields[field] = {
-        status,
-        value,
-        confidence,
-        source,
-        messageId,
-        updatedAt: now,
-        error: !validation.valid ? validation.error : undefined
-      };
-      session.effort.interactionCount++;
-      session.effort.lastInteractionAt = now;
-      session.effort.timeSpentMs = now - session.effort.firstInteractionAt;
-      session.expiresAt = this.calculateTTL(session);
-      const allRequiredFilled = this.checkAllRequiredFilled(session, form);
-      if (allRequiredFilled && session.status === "active") {
-        session.status = "ready";
-        if (form.hooks?.onReady) {
-          await this.executeHook(session, "onReady");
-        }
-      }
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-      if (form.hooks?.onFieldChange) {
-        const hookPayload = { field, value };
-        if (oldValue !== undefined) {
-          hookPayload.oldValue = oldValue;
-        }
-        await this.executeHook(session, "onFieldChange", hookPayload);
-      }
-    }
-    async undoLastChange(sessionId, entityId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form?.ux?.allowUndo) {
-        return null;
-      }
-      const lastChange = session.history.pop();
-      if (!lastChange) {
-        return null;
-      }
-      if (lastChange.oldValue !== undefined) {
-        session.fields[lastChange.field] = {
-          status: "filled",
-          value: lastChange.oldValue,
-          source: "correction",
-          updatedAt: Date.now()
-        };
-      } else {
-        session.fields[lastChange.field] = { status: "empty" };
-      }
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-      return { field: lastChange.field, restoredValue: lastChange.oldValue };
-    }
-    async skipField(sessionId, entityId, field) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form?.ux?.allowSkip) {
-        return false;
-      }
-      const control = form.controls.find((c) => c.key === field);
-      if (!control) {
-        return false;
-      }
-      if (control.required) {
-        return false;
-      }
-      session.fields[field] = {
-        status: "skipped",
-        updatedAt: Date.now()
-      };
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-      return true;
-    }
-    async confirmField(sessionId, entityId, field, accepted) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const fieldState = session.fields[field];
-      if (!fieldState || fieldState.status !== "uncertain") {
-        return;
-      }
-      const now = Date.now();
-      if (accepted) {
-        fieldState.status = "filled";
-        fieldState.confirmedAt = now;
-      } else {
-        fieldState.status = "empty";
-        fieldState.value = undefined;
-        fieldState.confidence = undefined;
-      }
-      fieldState.updatedAt = now;
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-    }
-    async updateSubField(sessionId, entityId, parentField, subField, value, confidence, messageId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form) {
-        throw new Error(`Form not found: ${session.formId}`);
-      }
-      const parentControl = form.controls.find((c) => c.key === parentField);
-      if (!parentControl) {
-        throw new Error(`Parent field not found: ${parentField}`);
-      }
-      const controlType = this.getControlType(parentControl.type);
-      if (!controlType?.getSubControls) {
-        throw new Error(`Control type '${parentControl.type}' is not a composite type`);
-      }
-      const subControls = controlType.getSubControls(parentControl, this.runtime);
-      const subControl = subControls.find((c) => c.key === subField);
-      if (!subControl) {
-        throw new Error(`Subfield not found: ${subField} in ${parentField}`);
-      }
-      const now = Date.now();
-      if (!session.fields[parentField]) {
-        session.fields[parentField] = { status: "empty" };
-      }
-      if (!session.fields[parentField].subFields) {
-        session.fields[parentField].subFields = {};
-      }
-      let subFieldStatus;
-      let error;
-      if (controlType.validate) {
-        const result = controlType.validate(value, subControl);
-        if (!result.valid) {
-          subFieldStatus = "invalid";
-          error = result.error;
-        } else if (confidence < (subControl.confirmThreshold ?? 0.8)) {
-          subFieldStatus = "uncertain";
-        } else {
-          subFieldStatus = "filled";
-        }
-      } else {
-        const validation = validateField(value, subControl);
-        if (!validation.valid) {
-          subFieldStatus = "invalid";
-          error = validation.error;
-        } else if (confidence < (subControl.confirmThreshold ?? 0.8)) {
-          subFieldStatus = "uncertain";
-        } else {
-          subFieldStatus = "filled";
-        }
-      }
-      session.fields[parentField].subFields[subField] = {
-        status: subFieldStatus,
-        value,
-        confidence,
-        source: "extraction",
-        messageId,
-        updatedAt: now,
-        error
-      };
-      session.effort.interactionCount++;
-      session.effort.lastInteractionAt = now;
-      session.effort.timeSpentMs = now - session.effort.firstInteractionAt;
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-      logger.debug(`[FormService] Updated subfield ${parentField}.${subField}`);
-    }
-    areSubFieldsFilled(session, parentField) {
-      const form = this.getForm(session.formId);
-      if (!form)
-        return false;
-      const parentControl = form.controls.find((c) => c.key === parentField);
-      if (!parentControl)
-        return false;
-      const controlType = this.getControlType(parentControl.type);
-      if (!controlType?.getSubControls)
-        return false;
-      const subControls = controlType.getSubControls(parentControl, this.runtime);
-      const subFields = session.fields[parentField]?.subFields || {};
-      for (const subControl of subControls) {
-        if (!subControl.required)
-          continue;
-        const subField = subFields[subControl.key];
-        if (!subField || subField.status !== "filled") {
-          return false;
-        }
-      }
-      return true;
-    }
-    getSubFieldValues(session, parentField) {
-      const subFields = session.fields[parentField]?.subFields || {};
-      const values = {};
-      for (const [key, state] of Object.entries(subFields)) {
-        if (state.value !== undefined) {
-          values[key] = state.value;
-        }
-      }
-      return values;
-    }
-    async activateExternalField(sessionId, entityId, field) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form) {
-        throw new Error(`Form not found: ${session.formId}`);
-      }
-      const control = form.controls.find((c) => c.key === field);
-      if (!control) {
-        throw new Error(`Field not found: ${field}`);
-      }
-      const controlType = this.getControlType(control.type);
-      if (!controlType?.activate) {
-        throw new Error(`Control type '${control.type}' does not support activation`);
-      }
-      const subValues = this.getSubFieldValues(session, field);
-      const context = {
-        runtime: this.runtime,
-        session,
-        control,
-        subValues
-      };
-      const activation = await controlType.activate(context);
-      const now = Date.now();
-      if (!session.fields[field]) {
-        session.fields[field] = { status: "empty" };
-      }
-      session.fields[field].status = "pending";
-      session.fields[field].externalState = {
-        status: "pending",
-        reference: activation.reference,
-        instructions: activation.instructions,
-        address: activation.address,
-        activatedAt: now
-      };
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-      logger.info(`[FormService] Activated external field ${field} with reference ${activation.reference}`);
-      return activation;
-    }
-    async confirmExternalField(sessionId, entityId, field, value, externalData) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const fieldState = session.fields[field];
-      if (!fieldState || fieldState.status !== "pending") {
-        logger.warn(`[FormService] Cannot confirm field ${field}: not in pending state`);
-        return;
-      }
-      const now = Date.now();
-      fieldState.status = "filled";
-      fieldState.value = value;
-      fieldState.source = "external";
-      fieldState.updatedAt = now;
-      if (fieldState.externalState) {
-        fieldState.externalState.status = "confirmed";
-        fieldState.externalState.confirmedAt = now;
-        fieldState.externalState.externalData = externalData;
-      }
-      const form = this.getForm(session.formId);
-      if (form && this.checkAllRequiredFilled(session, form)) {
-        if (session.status === "active") {
-          session.status = "ready";
-          if (form.hooks?.onReady) {
-            await this.executeHook(session, "onReady");
-          }
-        }
-      }
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-      try {
-        await this.runtime.emitEvent("FORM_FIELD_CONFIRMED", {
-          runtime: this.runtime,
-          sessionId,
-          entityId,
-          field,
-          value,
-          externalData
-        });
-      } catch (_error) {
-        logger.debug(`[FormService] No event handler for FORM_FIELD_CONFIRMED`);
-      }
-      logger.info(`[FormService] Confirmed external field ${field}`);
-    }
-    async cancelExternalField(sessionId, entityId, field, reason) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      const control = form?.controls.find((c) => c.key === field);
-      const controlType = control ? this.getControlType(control.type) : undefined;
-      if (controlType?.deactivate && control) {
-        try {
-          await controlType.deactivate({
-            runtime: this.runtime,
-            session,
-            control,
-            subValues: this.getSubFieldValues(session, field)
-          });
-        } catch (error) {
-          logger.error(`[FormService] Deactivate failed for ${field}: ${String(error)}`);
-        }
-      }
-      const fieldState = session.fields[field];
-      if (fieldState) {
-        fieldState.status = "empty";
-        fieldState.error = reason;
-        if (fieldState.externalState) {
-          fieldState.externalState.status = "failed";
-        }
-      }
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-      try {
-        await this.runtime.emitEvent("FORM_FIELD_CANCELLED", {
-          runtime: this.runtime,
-          sessionId,
-          entityId,
-          field,
-          reason
-        });
-      } catch (_error) {
-        logger.debug(`[FormService] No event handler for FORM_FIELD_CANCELLED`);
-      }
-      logger.info(`[FormService] Cancelled external field ${field}: ${reason}`);
-    }
-    async submit(sessionId, entityId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      if (!form) {
-        throw new Error(`Form not found: ${session.formId}`);
-      }
-      if (!this.checkAllRequiredFilled(session, form)) {
-        throw new Error("Not all required fields are filled");
-      }
-      const now = Date.now();
-      const values = {};
-      const mappedValues = {};
-      const files = {};
-      for (const control of form.controls) {
-        const fieldState = session.fields[control.key];
-        if (fieldState?.value !== undefined) {
-          values[control.key] = fieldState.value;
-          const dbKey = control.dbbind || control.key;
-          mappedValues[dbKey] = fieldState.value;
-        }
-        if (fieldState?.files) {
-          files[control.key] = fieldState.files;
-        }
-      }
-      const submission = {
-        id: v4_default(),
-        formId: session.formId,
-        formVersion: session.formVersion,
-        sessionId: session.id,
-        entityId: session.entityId,
-        values,
-        mappedValues,
-        files: Object.keys(files).length > 0 ? files : undefined,
-        submittedAt: now,
-        meta: session.meta
-      };
-      await saveSubmission(this.runtime, submission);
-      await saveAutofillData(this.runtime, entityId, session.formId, values);
-      session.status = "submitted";
-      session.submittedAt = now;
-      session.updatedAt = now;
-      await saveSession(this.runtime, session);
-      if (form.hooks?.onSubmit) {
-        const submissionPayload = JSON.parse(JSON.stringify(submission));
-        await this.executeHook(session, "onSubmit", {
-          submission: submissionPayload
-        });
-      }
-      logger.debug(`[FormService] Submitted session ${sessionId}`);
-      return submission;
-    }
-    async stash(sessionId, entityId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const form = this.getForm(session.formId);
-      session.status = "stashed";
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-      if (form?.hooks?.onCancel) {}
-      logger.debug(`[FormService] Stashed session ${sessionId}`);
-    }
-    async restore(sessionId, entityId) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      if (session.status !== "stashed") {
-        throw new Error(`Session is not stashed: ${session.status}`);
-      }
-      const existing = await getActiveSession(this.runtime, entityId, session.roomId);
-      if (existing && existing.id !== sessionId) {
-        throw new Error(`Active session already exists in room: ${existing.id}`);
-      }
-      session.status = "active";
-      session.updatedAt = Date.now();
-      session.expiresAt = this.calculateTTL(session);
-      await saveSession(this.runtime, session);
-      logger.debug(`[FormService] Restored session ${sessionId}`);
-      return session;
-    }
-    async cancel(sessionId, entityId, force = false) {
-      const session = await getSessionById(this.runtime, entityId, sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      if (!force && this.shouldConfirmCancel(session) && !session.cancelConfirmationAsked) {
-        session.cancelConfirmationAsked = true;
-        session.updatedAt = Date.now();
-        await saveSession(this.runtime, session);
-        return false;
-      }
-      const form = this.getForm(session.formId);
-      session.status = "cancelled";
-      session.updatedAt = Date.now();
-      await saveSession(this.runtime, session);
-      if (form?.hooks?.onCancel) {
-        await this.executeHook(session, "onCancel");
-      }
-      logger.debug(`[FormService] Cancelled session ${sessionId}`);
-      return true;
-    }
-    async getSubmissions(entityId, formId) {
-      return getSubmissions(this.runtime, entityId, formId);
-    }
-    async getAutofill(entityId, formId) {
-      const data = await getAutofillData(this.runtime, entityId, formId);
-      return data?.values || null;
-    }
-    async applyAutofill(session) {
-      const form = this.getForm(session.formId);
-      if (!form?.ux?.allowAutofill) {
-        return [];
-      }
-      const autofill = await getAutofillData(this.runtime, session.entityId, session.formId);
-      if (!autofill) {
-        return [];
-      }
-      const appliedFields = [];
-      const now = Date.now();
-      for (const control of form.controls) {
-        if (session.fields[control.key]?.status !== "empty") {
-          continue;
-        }
-        const value = autofill.values[control.key];
-        if (value !== undefined) {
-          session.fields[control.key] = {
-            status: "filled",
-            value,
-            source: "autofill",
-            updatedAt: now
-          };
-          appliedFields.push(control.key);
-        }
-      }
-      if (appliedFields.length > 0) {
-        session.updatedAt = now;
-        await saveSession(this.runtime, session);
-      }
-      return appliedFields;
-    }
-    getSessionContext(session) {
-      const form = this.getForm(session.formId);
-      if (!form) {
-        return {
-          hasActiveForm: false,
-          progress: 0,
-          filledFields: [],
-          missingRequired: [],
-          uncertainFields: [],
-          nextField: null,
-          pendingExternalFields: []
-        };
-      }
-      const filledFields = [];
-      const missingRequired = [];
-      const uncertainFields = [];
-      const pendingExternalFields = [];
-      let nextField = null;
-      let filledCount = 0;
-      let totalRequired = 0;
-      for (const control of form.controls) {
-        if (control.hidden)
-          continue;
-        const fieldState = session.fields[control.key];
-        if (control.required) {
-          totalRequired++;
-        }
-        if (fieldState?.status === "filled") {
-          filledCount++;
-          filledFields.push({
-            key: control.key,
-            label: control.label,
-            displayValue: formatValue(fieldState.value ?? null, control)
-          });
-        } else if (fieldState?.status === "pending") {
-          if (fieldState.externalState) {
-            pendingExternalFields.push({
-              key: control.key,
-              label: control.label,
-              instructions: fieldState.externalState.instructions || "Waiting for confirmation...",
-              reference: fieldState.externalState.reference || "",
-              activatedAt: fieldState.externalState.activatedAt || Date.now(),
-              address: fieldState.externalState.address
-            });
-          }
-        } else if (fieldState?.status === "uncertain") {
-          uncertainFields.push({
-            key: control.key,
-            label: control.label,
-            value: fieldState.value ?? null,
-            confidence: fieldState.confidence ?? 0
-          });
-        } else if (fieldState?.status === "invalid") {
-          missingRequired.push({
-            key: control.key,
-            label: control.label,
-            description: control.description,
-            askPrompt: control.askPrompt
-          });
-          if (!nextField)
-            nextField = control;
-        } else if (control.required && fieldState?.status !== "skipped") {
-          missingRequired.push({
-            key: control.key,
-            label: control.label,
-            description: control.description,
-            askPrompt: control.askPrompt
-          });
-          if (!nextField)
-            nextField = control;
-        } else if (!nextField && fieldState?.status === "empty") {
-          nextField = control;
-        }
-      }
-      const progress = totalRequired > 0 ? Math.round(filledCount / totalRequired * 100) : 100;
-      return {
-        hasActiveForm: true,
-        formId: session.formId,
-        formName: form.name,
-        progress,
-        filledFields,
-        missingRequired,
-        uncertainFields,
-        nextField,
-        status: session.status,
-        pendingCancelConfirmation: session.cancelConfirmationAsked && session.status === "active",
-        pendingExternalFields
-      };
-    }
-    getValues(session) {
-      const values = {};
-      for (const [key, state] of Object.entries(session.fields)) {
-        if (state.value !== undefined) {
-          values[key] = state.value;
-        }
-      }
-      return values;
-    }
-    getMappedValues(session) {
-      const form = this.getForm(session.formId);
-      if (!form)
-        return {};
-      const values = {};
-      for (const control of form.controls) {
-        const state = session.fields[control.key];
-        if (state?.value !== undefined) {
-          const key = control.dbbind || control.key;
-          values[key] = state.value;
-        }
-      }
-      return values;
-    }
-    calculateTTL(session) {
-      const form = this.getForm(session.formId);
-      const config = form?.ttl || {};
-      const minDays = config.minDays ?? 14;
-      const maxDays = config.maxDays ?? 90;
-      const multiplier = config.effortMultiplier ?? 0.5;
-      const minutesSpent = session.effort.timeSpentMs / 60000;
-      const effortDays = minutesSpent * multiplier;
-      const ttlDays = Math.min(maxDays, Math.max(minDays, effortDays));
-      return Date.now() + ttlDays * 24 * 60 * 60 * 1000;
-    }
-    shouldConfirmCancel(session) {
-      const minEffortMs = 5 * 60 * 1000;
-      return session.effort.timeSpentMs > minEffortMs;
-    }
-    async executeHook(session, hookName, options) {
-      const form = this.getForm(session.formId);
-      const workerName = form?.hooks?.[hookName];
-      if (!workerName)
-        return;
-      const worker = this.runtime.getTaskWorker(workerName);
-      if (!worker) {
-        logger.warn(`[FormService] Hook worker not found: ${workerName}`);
-        return;
-      }
-      try {
-        const task = {
-          id: session.id,
-          name: workerName,
-          roomId: session.roomId,
-          entityId: session.entityId,
-          tags: ["form-hook", hookName]
-        };
-        await worker.execute(this.runtime, {
-          session,
-          form,
-          ...options
-        }, task);
-      } catch (error) {
-        logger.error(`[FormService] Hook execution failed: ${hookName}`, String(error));
-      }
-    }
-    checkAllRequiredFilled(session, form) {
-      for (const control of form.controls) {
-        if (!control.required)
-          continue;
-        const fieldState = session.fields[control.key];
-        if (!fieldState || fieldState.status === "empty" || fieldState.status === "invalid") {
-          return false;
-        }
-      }
-      return true;
-    }
-  };
-});
-
-// src/actions/restore.ts
-var exports_restore = {};
-__export(exports_restore, {
-  formRestoreAction: () => formRestoreAction,
-  default: () => restore_default
-});
 import {
-  logger as logger2
-} from "@elizaos/core";
-var formRestoreAction, restore_default;
-var init_restore = __esm(() => {
-  formRestoreAction = {
-    name: "FORM_RESTORE",
-    similes: ["RESUME_FORM", "CONTINUE_FORM"],
-    description: "Restore a previously stashed form session",
-    validate: async (runtime, message, state, options) => {
-      const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-      const __avText = __avTextRaw.toLowerCase();
-      const __avKeywords = ["form", "restore"];
-      const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-      const __avRegex = /\b(?:form|restore)\b/i;
-      const __avRegexOk = Boolean(__avText.match(__avRegex));
-      const __avSource = String(message?.content?.source ?? message?.source ?? "");
-      const __avExpectedSource = "";
-      const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-      const __avOptions = options && typeof options === "object" ? options : {};
-      const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-      if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-        return false;
-      }
-      const __avLegacyValidate = async (runtime2, message2, _state) => {
-        try {
-          const text = message2.content?.text || "";
-          const intent = quickIntentDetect(text);
-          if (intent !== "restore") {
-            return false;
-          }
-          const formService = runtime2.getService("FORM");
-          if (!formService) {
-            return false;
-          }
-          const entityId = message2.entityId;
-          if (!entityId)
-            return false;
-          const stashed = await formService.getStashedSessions(entityId);
-          return stashed.length > 0;
-        } catch (error) {
-          logger2.error("[FormRestoreAction] Validation error:", String(error));
-          return false;
-        }
-      };
-      try {
-        return Boolean(await __avLegacyValidate(runtime, message, state, options));
-      } catch {
-        return false;
-      }
-    },
-    handler: async (runtime, message, _state, _options, callback) => {
-      try {
-        const formService = runtime.getService("FORM");
-        if (!formService) {
-          await callback?.({
-            text: "Sorry, I couldn't find the form service."
-          });
-          return { success: false };
-        }
-        const entityId = message.entityId;
-        const roomId = message.roomId;
-        if (!entityId || !roomId) {
-          await callback?.({
-            text: "Sorry, I couldn't identify you."
-          });
-          return { success: false };
-        }
-        const existing = await formService.getActiveSession(entityId, roomId);
-        if (existing) {
-          const form2 = formService.getForm(existing.formId);
-          await callback?.({
-            text: `You already have an active form: "${form2?.name || existing.formId}". Would you like to continue with that one, or should I save it and restore your other form?`
-          });
-          return { success: false };
-        }
-        const stashed = await formService.getStashedSessions(entityId);
-        if (stashed.length === 0) {
-          await callback?.({
-            text: "You don't have any saved forms to resume."
-          });
-          return { success: false };
-        }
-        const sessionToRestore = stashed.sort((a, b) => b.updatedAt - a.updatedAt)[0];
-        const session = await formService.restore(sessionToRestore.id, entityId);
-        const form = formService.getForm(session.formId);
-        const context = formService.getSessionContext(session);
-        let responseText = `I've restored your "${form?.name || session.formId}" form. `;
-        responseText += `You're ${context.progress}% complete. `;
-        if (context.filledFields.length > 0) {
-          responseText += `
-
-Here's what I have so far:
-`;
-          for (const field of context.filledFields) {
-            responseText += `• ${field.label}: ${field.displayValue}
-`;
-          }
-        }
-        if (context.nextField) {
-          responseText += `
-Let's continue with ${context.nextField.label}.`;
-          if (context.nextField.askPrompt) {
-            responseText += ` ${context.nextField.askPrompt}`;
-          }
-        } else if (context.status === "ready") {
-          responseText += `
-Everything looks complete! Ready to submit?`;
-        }
-        await callback?.({
-          text: responseText
-        });
-        return {
-          success: true,
-          data: {
-            sessionId: session.id,
-            formId: session.formId,
-            progress: context.progress
-          }
-        };
-      } catch (error) {
-        logger2.error("[FormRestoreAction] Handler error:", String(error));
-        await callback?.({
-          text: "Sorry, I couldn't restore your form. Please try again."
-        });
-        return { success: false };
-      }
-    },
-    examples: [
-      [
-        {
-          name: "{{user1}}",
-          content: { text: "Resume my form" }
-        },
-        {
-          name: "{{agentName}}",
-          content: {
-            text: "I've restored your form. Let's continue where you left off."
-          }
-        }
-      ],
-      [
-        {
-          name: "{{user1}}",
-          content: { text: "Continue with my registration" }
-        },
-        {
-          name: "{{agentName}}",
-          content: {
-            text: "I've restored your Registration form. You're 60% complete."
-          }
-        }
-      ],
-      [
-        {
-          name: "{{user1}}",
-          content: { text: "Pick up where I left off" }
-        },
-        {
-          name: "{{agentName}}",
-          content: {
-            text: "I've restored your form. Here's what you have so far..."
-          }
-        }
-      ]
-    ]
-  };
-  restore_default = formRestoreAction;
-});
-
-// src/evaluators/extractor.ts
-var exports_extractor = {};
-__export(exports_extractor, {
-  formEvaluator: () => formEvaluator,
-  default: () => extractor_default
-});
-import { logger as logger3 } from "@elizaos/core";
-async function processExtractions(runtime, formService, session, form, entityId, extractions, messageId) {
-  const updatedParents = new Set;
-  for (const extraction of extractions) {
-    if (extraction.field.includes(".")) {
-      const [parentKey, subKey] = extraction.field.split(".");
-      await formService.updateSubField(session.id, entityId, parentKey, subKey, extraction.value, extraction.confidence, messageId);
-      await emitEvent(runtime, "FORM_SUBFIELD_UPDATED", {
-        sessionId: session.id,
-        parentField: parentKey,
-        subField: subKey,
-        value: extraction.value,
-        confidence: extraction.confidence
-      });
-      updatedParents.add(parentKey);
-      if (form.debug) {
-        logger3.debug(`[FormEvaluator] Updated subfield ${parentKey}.${subKey}`);
-      }
-    } else {
-      await formService.updateField(session.id, entityId, extraction.field, extraction.value, extraction.confidence, extraction.isCorrection ? "correction" : "extraction", messageId);
-      await emitEvent(runtime, "FORM_FIELD_EXTRACTED", {
-        sessionId: session.id,
-        field: extraction.field,
-        value: extraction.value,
-        confidence: extraction.confidence
-      });
-      if (form.debug) {
-        logger3.debug(`[FormEvaluator] Updated field ${extraction.field}`);
-      }
-    }
-  }
-  for (const parentKey of updatedParents) {
-    await checkAndActivateExternalField(runtime, formService, session, form, entityId, parentKey);
-  }
-}
-async function checkAndActivateExternalField(runtime, formService, session, form, entityId, field) {
-  const freshSession = await formService.getActiveSession(entityId, session.roomId);
-  if (!freshSession)
-    return;
-  if (!formService.isExternalType(form.controls.find((c) => c.key === field)?.type || "")) {
-    return;
-  }
-  if (!formService.areSubFieldsFilled(freshSession, field)) {
-    return;
-  }
-  const subValues = formService.getSubFieldValues(freshSession, field);
-  await emitEvent(runtime, "FORM_SUBCONTROLS_FILLED", {
-    sessionId: session.id,
-    field,
-    subValues
-  });
-  logger3.debug(`[FormEvaluator] All subcontrols filled for ${field}, activating...`);
-  try {
-    const activation = await formService.activateExternalField(session.id, entityId, field);
-    const activationPayload = JSON.parse(JSON.stringify(activation));
-    await emitEvent(runtime, "FORM_EXTERNAL_ACTIVATED", {
-      sessionId: session.id,
-      field,
-      activation: activationPayload
-    });
-    logger3.info(`[FormEvaluator] Activated external field ${field}: ${activation.instructions}`);
-  } catch (error) {
-    logger3.error(`[FormEvaluator] Failed to activate external field ${field}:`, String(error));
-  }
-}
-async function emitEvent(runtime, eventType, payload) {
-  try {
-    if (typeof runtime.emitEvent === "function") {
-      const eventPayload = { runtime, ...payload };
-      await runtime.emitEvent(eventType, eventPayload);
-    }
-  } catch (error) {
-    logger3.debug(`[FormEvaluator] Event emission (${eventType}):`, String(error));
-  }
-}
-async function handleSubmit(formService, session, entityId) {
-  try {
-    await formService.submit(session.id, entityId);
-  } catch (error) {
-    logger3.debug("[FormEvaluator] Submit failed:", String(error));
-  }
-}
-async function handleUndo(formService, session, entityId, form) {
-  if (!form.ux?.allowUndo) {
-    return;
-  }
-  const result = await formService.undoLastChange(session.id, entityId);
-  if (result) {
-    logger3.debug("[FormEvaluator] Undid field:", result.field);
-  }
-}
-async function handleSkip(formService, session, entityId, form) {
-  if (!form.ux?.allowSkip) {
-    return;
-  }
-  if (session.lastAskedField) {
-    const skipped = await formService.skipField(session.id, entityId, session.lastAskedField);
-    if (skipped) {
-      logger3.debug("[FormEvaluator] Skipped field:", session.lastAskedField);
-    }
-  }
-}
-var formEvaluator, extractor_default;
-var init_extractor = __esm(() => {
-  init_extraction();
-  init_template();
-  formEvaluator = {
-    name: "form_evaluator",
-    description: "Extracts form fields and handles form intents from user messages",
-    similes: ["FORM_EXTRACTION", "FORM_HANDLER"],
-    examples: [],
-    validate: async (runtime, message, _state) => {
-      try {
-        const formService = runtime.getService("FORM");
-        if (!formService)
-          return false;
-        const entityId = message.entityId;
-        const roomId = message.roomId;
-        if (!entityId || !roomId)
-          return false;
-        const session = await formService.getActiveSession(entityId, roomId);
-        const stashed = await formService.getStashedSessions(entityId);
-        return session !== null || stashed.length > 0;
-      } catch (error) {
-        logger3.error("[FormEvaluator] Validation error:", String(error));
-        return false;
-      }
-    },
-    handler: async (runtime, message, _state) => {
-      try {
-        const formService = runtime.getService("FORM");
-        if (!formService)
-          return;
-        const entityId = message.entityId;
-        const roomId = message.roomId;
-        const text = message.content?.text || "";
-        if (!entityId || !roomId)
-          return;
-        if (!text.trim())
-          return;
-        let session = await formService.getActiveSession(entityId, roomId);
-        let intent = quickIntentDetect(text);
-        let extractions = [];
-        if (intent === "restore" && !session) {
-          logger3.debug("[FormEvaluator] Restore intent detected, deferring to action");
-          return;
-        }
-        if (!session) {
-          return;
-        }
-        const form = formService.getForm(session.formId);
-        if (!form) {
-          logger3.warn("[FormEvaluator] Form not found for session:", session.formId);
-          return;
-        }
-        const templateValues = buildTemplateValues(session);
-        if (!intent) {
-          const result = await llmIntentAndExtract(runtime, text, form, form.controls, templateValues);
-          intent = result.intent;
-          extractions = result.extractions;
-          if (form.debug) {
-            logger3.debug("[FormEvaluator] LLM extraction result:", JSON.stringify({ intent, extractions }));
-          }
-        }
-        switch (intent) {
-          case "submit":
-            await handleSubmit(formService, session, entityId);
-            break;
-          case "stash":
-            await formService.stash(session.id, entityId);
-            break;
-          case "cancel":
-            await formService.cancel(session.id, entityId);
-            break;
-          case "undo":
-            await handleUndo(formService, session, entityId, form);
-            break;
-          case "skip":
-            await handleSkip(formService, session, entityId, form);
-            break;
-          case "autofill":
-            await formService.applyAutofill(session);
-            break;
-          case "explain":
-          case "example":
-          case "progress":
-            logger3.debug(`[FormEvaluator] Info intent: ${intent}`);
-            break;
-          case "restore":
-            logger3.debug("[FormEvaluator] Restore intent - deferring to action");
-            break;
-          default:
-            await processExtractions(runtime, formService, session, form, entityId, extractions, message.id);
-            break;
-        }
-        session = await formService.getActiveSession(entityId, roomId);
-        if (session) {
-          session.lastMessageId = message.id;
-          await formService.saveSession(session);
-        }
-      } catch (error) {
-        logger3.error("[FormEvaluator] Handler error:", String(error));
-        return;
-      }
-      return;
-    }
-  };
-  extractor_default = formEvaluator;
-});
-
-// src/providers/context.ts
-var exports_context = {};
-__export(exports_context, {
-  formContextProvider: () => formContextProvider,
-  default: () => context_default
-});
-import { logger as logger4 } from "@elizaos/core";
-var formContextProvider, context_default;
-var init_context = __esm(() => {
-  init_template();
-  formContextProvider = {
-    name: "FORM_CONTEXT",
-    description: "Provides context about active form sessions",
-    dynamic: true,
-    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 resolveText = (value) => renderTemplate(value, templateValues);
-          contextState = {
-            ...contextState,
-            filledFields: contextState.filledFields.map((field) => ({
-              ...field,
-              label: resolveText(field.label) ?? field.label
-            })),
-            missingRequired: contextState.missingRequired.map((field) => ({
-              ...field,
-              label: resolveText(field.label) ?? field.label,
-              description: resolveText(field.description),
-              askPrompt: resolveText(field.askPrompt)
-            })),
-            uncertainFields: contextState.uncertainFields.map((field) => ({
-              ...field,
-              label: resolveText(field.label) ?? field.label
-            })),
-            nextField: contextState.nextField ? resolveControlTemplates(contextState.nextField, templateValues) : null
-          };
-          contextText = `# Active Form: ${form?.name || session.formId}
-
-`;
-          contextText += `Progress: ${contextState.progress}%
-
-`;
-          if (contextState.filledFields.length > 0) {
-            contextText += `## Collected Information
-`;
-            for (const field of contextState.filledFields) {
-              contextText += `- ${field.label}: ${field.displayValue}
-`;
-            }
-            contextText += `
-`;
-          }
-          if (contextState.missingRequired.length > 0) {
-            contextText += `## Still Needed
-`;
-            for (const field of contextState.missingRequired) {
-              contextText += `- ${field.label}${field.description ? ` (${field.description})` : ""}
-`;
-            }
-            contextText += `
-`;
-          }
-          if (contextState.uncertainFields.length > 0) {
-            contextText += `## Needs Confirmation
-`;
-            for (const field of contextState.uncertainFields) {
-              contextText += `- ${field.label}: "${field.value}" (${Math.round(field.confidence * 100)}% confident)
-`;
-            }
-            contextText += `
-`;
-          }
-          if (contextState.pendingExternalFields.length > 0) {
-            contextText += `## Waiting For External Action
-`;
-            for (const field of contextState.pendingExternalFields) {
-              const ageMs = Date.now() - field.activatedAt;
-              const ageMin = Math.floor(ageMs / 60000);
-              const ageText = ageMin < 1 ? "just now" : `${ageMin}m ago`;
-              contextText += `- ${field.label}: ${field.instructions} (started ${ageText})
-`;
-              if (field.address) {
-                contextText += `  Address: ${field.address}
-`;
-              }
-            }
-            contextText += `
-`;
-          }
-          contextText += `## Agent Guidance
-`;
-          if (contextState.pendingExternalFields.length > 0) {
-            const pending = contextState.pendingExternalFields[0];
-            contextText += `Waiting for external action. Remind user: "${pending.instructions}"
-`;
-          } else if (contextState.pendingCancelConfirmation) {
-            contextText += `User is trying to cancel. Confirm: "You've spent time on this. Are you sure you want to cancel?"
-`;
-          } else if (contextState.uncertainFields.length > 0) {
-            const uncertain = contextState.uncertainFields[0];
-            contextText += `Ask user to confirm: "I understood your ${uncertain.label} as '${uncertain.value}'. Is that correct?"
-`;
-          } else if (contextState.nextField) {
-            const next = contextState.nextField;
-            const prompt = next.askPrompt || `Ask for their ${next.label}`;
-            contextText += `Next: ${prompt}
-`;
-            if (next.example) {
-              contextText += `Example: "${next.example}"
-`;
-            }
-          } else if (contextState.status === "ready") {
-            contextText += `All fields collected! Nudge user to submit: "I have everything I need. Ready to submit?"
-`;
-          }
-          contextText += `
-`;
-          contextText += `## User Can Say
-`;
-          contextText += `- Provide information for any field
-`;
-          contextText += `- "undo" or "go back" to revert last change
-`;
-          contextText += `- "skip" to skip optional fields
-`;
-          contextText += `- "why?" to get explanation about a field
-`;
-          contextText += `- "how far?" to check progress
-`;
-          contextText += `- "submit" or "done" when ready
-`;
-          contextText += `- "save for later" to stash the form
-`;
-          contextText += `- "cancel" to abandon the form
-`;
-        } else {
-          contextState = {
-            hasActiveForm: false,
-            progress: 0,
-            filledFields: [],
-            missingRequired: [],
-            uncertainFields: [],
-            nextField: null,
-            stashedCount: stashed.length,
-            pendingExternalFields: []
-          };
-        }
-        if (stashed.length > 0) {
-          contextText += `
-## Saved Forms
-`;
-          contextText += `User has ${stashed.length} saved form(s). They can say "resume" or "continue" to restore one.
-`;
-          for (const s of stashed) {
-            const form = formService.getForm(s.formId);
-            const ctx = formService.getSessionContext(s);
-            contextText += `- ${form?.name || s.formId} (${ctx.progress}% complete)
-`;
-          }
-        }
-        return {
-          data: JSON.parse(JSON.stringify(contextState)),
-          values: {
-            formContext: contextText,
-            hasActiveForm: String(contextState.hasActiveForm),
-            formProgress: String(contextState.progress),
-            formStatus: contextState.status || "",
-            stashedCount: String(stashed.length)
-          },
-          text: contextText
-        };
-      } catch (error) {
-        logger4.error("[FormContextProvider] Error:", String(error));
-        return {
-          data: { hasActiveForm: false, error: true },
-          values: { formContext: "Error loading form context." },
-          text: "Error loading form context."
-        };
-      }
-    }
-  };
-  context_default = formContextProvider;
-});
-
-// index.ts
-init_builtins();
-init_validation();
-init_storage();
-init_extraction();
-init_types();
+  BUILTIN_TYPES,
+  BUILTIN_TYPE_MAP,
+  FORM_AUTOFILL_COMPONENT,
+  FORM_CONTROL_DEFAULTS,
+  FORM_DEFINITION_DEFAULTS,
+  FORM_SESSION_COMPONENT,
+  FORM_SUBMISSION_COMPONENT,
+  FormService,
+  deleteSession,
+  getActiveSession,
+  getAllActiveSessions,
+  getAutofillData,
+  getBuiltinType,
+  getStashedSessions,
+  getSubmissions,
+  isBuiltinType,
+  registerBuiltinTypes,
+  saveAutofillData,
+  saveSession,
+  saveSubmission
+} from "./chunk-R4VBS2YK.js";
+import {
+  formRestoreAction
+} from "./chunk-TBCL2ILB.js";
+import {
+  detectCorrection,
+  extractSingleField,
+  formEvaluator,
+  llmIntentAndExtract
+} from "./chunk-XHECCAUT.js";
+import {
+  clearTypeHandlers,
+  formatValue,
+  getTypeHandler,
+  matchesMimeType,
+  parseValue,
+  registerTypeHandler,
+  validateField
+} from "./chunk-ARWZY3NX.js";
+import {
+  hasDataToExtract,
+  isLifecycleIntent,
+  isUXIntent,
+  quickIntentDetect
+} from "./chunk-YTWANJ3R.js";
+import {
+  formContextProvider
+} from "./chunk-4B5QLNVA.js";
+import "./chunk-WY4WK3HD.js";
 
 // src/ttl.ts
-init_types();
 function calculateTTL(session, form) {
   const config = form?.ttl || {};
   const minDays = config.minDays ?? FORM_DEFINITION_DEFAULTS.ttl.minDays;
   const maxDays = config.maxDays ?? FORM_DEFINITION_DEFAULTS.ttl.maxDays;
   const multiplier = config.effortMultiplier ?? FORM_DEFINITION_DEFAULTS.ttl.effortMultiplier;
-  const minutesSpent = session.effort.timeSpentMs / 60000;
+  const minutesSpent = session.effort.timeSpentMs / 6e4;
   const effortDays = minutesSpent * multiplier;
   const ttlDays = Math.min(maxDays, Math.max(minDays, effortDays));
-  return Date.now() + ttlDays * 24 * 60 * 60 * 1000;
+  return Date.now() + ttlDays * 24 * 60 * 60 * 1e3;
 }
 function shouldNudge(session, form) {
   const nudgeConfig = form?.nudge;
@@ -2667,14 +70,14 @@ function shouldNudge(session, form) {
     return false;
   }
   const afterInactiveHours = nudgeConfig?.afterInactiveHours ?? FORM_DEFINITION_DEFAULTS.nudge.afterInactiveHours;
-  const inactiveMs = afterInactiveHours * 60 * 60 * 1000;
+  const inactiveMs = afterInactiveHours * 60 * 60 * 1e3;
   const timeSinceInteraction = Date.now() - session.effort.lastInteractionAt;
   if (timeSinceInteraction < inactiveMs) {
     return false;
   }
   if (session.lastNudgeAt) {
     const timeSinceNudge = Date.now() - session.lastNudgeAt;
-    if (timeSinceNudge < 24 * 60 * 60 * 1000) {
+    if (timeSinceNudge < 24 * 60 * 60 * 1e3) {
       return false;
     }
   }
@@ -2687,7 +90,7 @@ function isExpired(session) {
   return session.expiresAt < Date.now();
 }
 function shouldConfirmCancel(session) {
-  const minEffortMs = 5 * 60 * 1000;
+  const minEffortMs = 5 * 60 * 1e3;
   return session.effort.timeSpentMs > minEffortMs;
 }
 function formatTimeRemaining(session) {
@@ -2695,7 +98,7 @@ function formatTimeRemaining(session) {
   if (remaining <= 0) {
     return "expired";
   }
-  const hours = Math.floor(remaining / (60 * 60 * 1000));
+  const hours = Math.floor(remaining / (60 * 60 * 1e3));
   const days = Math.floor(hours / 24);
   if (days > 0) {
     return `${days} day${days > 1 ? "s" : ""}`;
@@ -2703,11 +106,11 @@ function formatTimeRemaining(session) {
   if (hours > 0) {
     return `${hours} hour${hours > 1 ? "s" : ""}`;
   }
-  const minutes = Math.floor(remaining / (60 * 1000));
+  const minutes = Math.floor(remaining / (60 * 1e3));
   return `${minutes} minute${minutes > 1 ? "s" : ""}`;
 }
 function formatEffort(session) {
-  const minutes = Math.floor(session.effort.timeSpentMs / 60000);
+  const minutes = Math.floor(session.effort.timeSpentMs / 6e4);
   if (minutes < 1) {
     return "just started";
   }
@@ -2721,25 +124,41 @@ function formatEffort(session) {
   }
   return `${hours}h ${remainingMinutes}m`;
 }
+
 // src/defaults.ts
-init_types();
 function applyControlDefaults(control) {
   return {
+    // Required field (must be present)
     key: control.key,
+    // Derive label from key if not provided
+    // WHY: User sees labels, default should be readable
     label: control.label || prettify(control.key),
+    // Default type is text (most common)
     type: control.type || FORM_CONTROL_DEFAULTS.type,
+    // Default not required (explicit opt-in)
+    // WHY: Safer to require opt-in for required fields
     required: control.required ?? FORM_CONTROL_DEFAULTS.required,
+    // Default confidence threshold for auto-acceptance
+    // WHY 0.8: High enough to be confident, low enough to be useful
     confirmThreshold: control.confirmThreshold ?? FORM_CONTROL_DEFAULTS.confirmThreshold,
+    // Spread remaining properties (override defaults)
     ...control
   };
 }
 function applyFormDefaults(form) {
   return {
+    // Required fields
     id: form.id,
+    // Derive name from id if not provided
     name: form.name || prettify(form.id),
+    // Default version for schema tracking
     version: form.version ?? FORM_DEFINITION_DEFAULTS.version,
+    // Default status is active
     status: form.status ?? FORM_DEFINITION_DEFAULTS.status,
+    // Apply defaults to all controls
     controls: (form.controls || []).map(applyControlDefaults),
+    // UX defaults - enable helpful features by default
+    // WHY enable by default: Better user experience out of the box
     ux: {
       allowUndo: form.ux?.allowUndo ?? FORM_DEFINITION_DEFAULTS.ux.allowUndo,
       allowSkip: form.ux?.allowSkip ?? FORM_DEFINITION_DEFAULTS.ux.allowSkip,
@@ -2748,190 +167,266 @@ function applyFormDefaults(form) {
       showExplanations: form.ux?.showExplanations ?? FORM_DEFINITION_DEFAULTS.ux.showExplanations,
       allowAutofill: form.ux?.allowAutofill ?? FORM_DEFINITION_DEFAULTS.ux.allowAutofill
     },
+    // TTL defaults - generous retention
+    // WHY generous: Better to keep data too long than lose user work
     ttl: {
       minDays: form.ttl?.minDays ?? FORM_DEFINITION_DEFAULTS.ttl.minDays,
       maxDays: form.ttl?.maxDays ?? FORM_DEFINITION_DEFAULTS.ttl.maxDays,
       effortMultiplier: form.ttl?.effortMultiplier ?? FORM_DEFINITION_DEFAULTS.ttl.effortMultiplier
     },
+    // Nudge defaults - helpful but not annoying
     nudge: {
       enabled: form.nudge?.enabled ?? FORM_DEFINITION_DEFAULTS.nudge.enabled,
       afterInactiveHours: form.nudge?.afterInactiveHours ?? FORM_DEFINITION_DEFAULTS.nudge.afterInactiveHours,
       maxNudges: form.nudge?.maxNudges ?? FORM_DEFINITION_DEFAULTS.nudge.maxNudges,
       message: form.nudge?.message
     },
+    // Debug defaults to off for performance
     debug: form.debug ?? FORM_DEFINITION_DEFAULTS.debug,
+    // Spread remaining properties (override defaults)
     ...form
   };
 }
 function prettify(key) {
   return key.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
+
 // src/builder.ts
-class ControlBuilder {
+var ControlBuilder = class _ControlBuilder {
+  /** Partial control being built */
   control;
+  /**
+   * Create a new ControlBuilder.
+   *
+   * @param key - The unique key for this control
+   */
   constructor(key) {
     this.control = { key };
   }
+  // ═══ STATIC FACTORIES ═══
+  // WHY static factories: Cleaner than `new ControlBuilder(key).type('text')`
+  /** Create a generic field builder */
   static field(key) {
-    return new ControlBuilder(key);
+    return new _ControlBuilder(key);
   }
+  /** Create a text field */
   static text(key) {
-    return new ControlBuilder(key).type("text");
+    return new _ControlBuilder(key).type("text");
   }
+  /** Create an email field */
   static email(key) {
-    return new ControlBuilder(key).type("email");
+    return new _ControlBuilder(key).type("email");
   }
+  /** Create a number field */
   static number(key) {
-    return new ControlBuilder(key).type("number");
+    return new _ControlBuilder(key).type("number");
   }
+  /** Create a boolean (yes/no) field */
   static boolean(key) {
-    return new ControlBuilder(key).type("boolean");
+    return new _ControlBuilder(key).type("boolean");
   }
+  /** Create a select field with options */
   static select(key, options) {
-    return new ControlBuilder(key).type("select").options(options);
+    return new _ControlBuilder(key).type("select").options(options);
   }
+  /** Create a date field */
   static date(key) {
-    return new ControlBuilder(key).type("date");
+    return new _ControlBuilder(key).type("date");
   }
+  /** Create a file upload field */
   static file(key) {
-    return new ControlBuilder(key).type("file");
+    return new _ControlBuilder(key).type("file");
   }
+  // ═══ TYPE ═══
+  /** Set the field type */
   type(type) {
     this.control.type = type;
     return this;
   }
+  // ═══ BEHAVIOR ═══
+  /** Mark field as required */
   required() {
     this.control.required = true;
     return this;
   }
+  /** Mark field as optional (default) */
   optional() {
     this.control.required = false;
     return this;
   }
+  /** Mark field as hidden (extract silently, never ask) */
   hidden() {
     this.control.hidden = true;
     return this;
   }
+  /** Mark field as sensitive (don't echo value back) */
   sensitive() {
     this.control.sensitive = true;
     return this;
   }
+  /** Mark field as readonly (can't change after set) */
   readonly() {
     this.control.readonly = true;
     return this;
   }
+  /** Mark field as accepting multiple values */
   multiple() {
     this.control.multiple = true;
     return this;
   }
+  // ═══ VALIDATION ═══
+  /** Set regex pattern for validation */
   pattern(regex) {
     this.control.pattern = regex;
     return this;
   }
+  /** Set minimum value (for numbers) or minimum length (via minLength) */
   min(n) {
     this.control.min = n;
     return this;
   }
+  /** Set maximum value (for numbers) or maximum length (via maxLength) */
   max(n) {
     this.control.max = n;
     return this;
   }
+  /** Set minimum string length */
   minLength(n) {
     this.control.minLength = n;
     return this;
   }
+  /** Set maximum string length */
   maxLength(n) {
     this.control.maxLength = n;
     return this;
   }
+  /** Set allowed values (enum) */
   enum(values) {
     this.control.enum = values;
     return this;
   }
+  /** Set select options */
   options(opts) {
     this.control.options = opts;
     return this;
   }
+  // ═══ AGENT HINTS ═══
+  // WHY agent hints: Help LLM extract values correctly
+  /** Set human-readable label */
   label(label) {
     this.control.label = label;
     return this;
   }
+  /** Set custom prompt for asking this field */
   ask(prompt) {
     this.control.askPrompt = prompt;
     return this;
   }
+  /** Set description for LLM context */
   description(desc) {
     this.control.description = desc;
     return this;
   }
+  /** Add extraction hints (keywords to look for) */
   hint(...hints) {
     this.control.extractHints = hints;
     return this;
   }
+  /** Set example value for "give me an example" */
   example(value) {
     this.control.example = value;
     return this;
   }
+  /** Set confidence threshold for auto-acceptance */
   confirmThreshold(n) {
     this.control.confirmThreshold = n;
     return this;
   }
+  // ═══ FILE OPTIONS ═══
+  /** Set accepted MIME types for file upload */
   accept(mimeTypes) {
     this.control.file = { ...this.control.file, accept: mimeTypes };
     return this;
   }
+  /** Set maximum file size in bytes */
   maxSize(bytes) {
     this.control.file = { ...this.control.file, maxSize: bytes };
     return this;
   }
+  /** Set maximum number of files */
   maxFiles(n) {
     this.control.file = { ...this.control.file, maxFiles: n };
     return this;
   }
+  // ═══ ACCESS ═══
+  /** Set roles that can see/fill this field */
   roles(...roles) {
     this.control.roles = roles;
     return this;
   }
+  // ═══ DEFAULTS & CONDITIONS ═══
+  /** Set default value */
   default(value) {
     this.control.defaultValue = value;
     return this;
   }
+  /** Set dependency on another field */
   dependsOn(field, condition = "exists", value) {
     this.control.dependsOn = { field, condition, value };
     return this;
   }
+  // ═══ DATABASE ═══
+  /** Set database column name (defaults to key) */
   dbbind(columnName) {
     this.control.dbbind = columnName;
     return this;
   }
+  // ═══ UI ═══
+  /** Set section name for grouping */
   section(name) {
     this.control.ui = { ...this.control.ui, section: name };
     return this;
   }
+  /** Set display order within section */
   order(n) {
     this.control.ui = { ...this.control.ui, order: n };
     return this;
   }
+  /** Set placeholder text */
   placeholder(text) {
     this.control.ui = { ...this.control.ui, placeholder: text };
     return this;
   }
+  /** Set help text */
   helpText(text) {
     this.control.ui = { ...this.control.ui, helpText: text };
     return this;
   }
+  /** Set custom widget type */
   widget(type) {
     this.control.ui = { ...this.control.ui, widget: type };
     return this;
   }
+  // ═══ I18N ═══
+  /** Add localized text for a locale */
   i18n(locale, translations) {
     this.control.i18n = { ...this.control.i18n, [locale]: translations };
     return this;
   }
+  // ═══ META ═══
+  /** Add custom metadata */
   meta(key, value) {
     this.control.meta = { ...this.control.meta, [key]: value };
     return this;
   }
+  // ═══ BUILD ═══
+  /**
+   * Build the final FormControl.
+   *
+   * Applies defaults and validates the control.
+   *
+   * @returns Complete FormControl object
+   */
   build() {
     const control = {
       key: this.control.key,
@@ -2941,131 +436,190 @@ class ControlBuilder {
     };
     return control;
   }
-}
-
-class FormBuilder {
+};
+var FormBuilder = class _FormBuilder {
+  /** Partial form being built */
   form;
+  /**
+   * Create a new FormBuilder.
+   *
+   * @param id - Unique form identifier
+   */
   constructor(id) {
     this.form = { id, controls: [] };
   }
+  // ═══ STATIC FACTORY ═══
+  /** Create a new form builder */
   static create(id) {
-    return new FormBuilder(id);
+    return new _FormBuilder(id);
   }
+  // ═══ METADATA ═══
+  /** Set form name */
   name(name) {
     this.form.name = name;
     return this;
   }
+  /** Set form description */
   description(desc) {
     this.form.description = desc;
     return this;
   }
+  /** Set form version */
   version(v) {
     this.form.version = v;
     return this;
   }
+  // ═══ CONTROLS ═══
+  /**
+   * Add a control to the form.
+   *
+   * Accepts either a ControlBuilder (calls .build()) or a FormControl.
+   */
   control(builder) {
     const ctrl = builder instanceof ControlBuilder ? builder.build() : builder;
     this.form.controls?.push(ctrl);
     return this;
   }
+  /** Add multiple controls */
   controls(...builders) {
     for (const builder of builders) {
       this.control(builder);
     }
     return this;
   }
+  // ═══ SHORTHAND CONTROLS ═══
+  // WHY shorthands: Quick form prototyping
+  /** Add required text fields */
   required(...keys) {
     for (const key of keys) {
       this.control(ControlBuilder.field(key).required());
     }
     return this;
   }
+  /** Add optional text fields */
   optional(...keys) {
     for (const key of keys) {
       this.control(ControlBuilder.field(key));
     }
     return this;
   }
+  // ═══ PERMISSIONS ═══
+  /** Set roles that can start this form */
   roles(...roles) {
     this.form.roles = roles;
     return this;
   }
+  /** Allow multiple submissions per user */
   allowMultiple() {
     this.form.allowMultiple = true;
     return this;
   }
+  // ═══ UX ═══
+  /** Disable undo functionality */
   noUndo() {
     this.form.ux = { ...this.form.ux, allowUndo: false };
     return this;
   }
+  /** Disable skip functionality */
   noSkip() {
     this.form.ux = { ...this.form.ux, allowSkip: false };
     return this;
   }
+  /** Disable autofill */
   noAutofill() {
     this.form.ux = { ...this.form.ux, allowAutofill: false };
     return this;
   }
+  /** Set maximum undo steps */
   maxUndoSteps(n) {
     this.form.ux = { ...this.form.ux, maxUndoSteps: n };
     return this;
   }
+  // ═══ TTL ═══
+  /** Configure TTL (time-to-live) settings */
   ttl(config) {
     this.form.ttl = { ...this.form.ttl, ...config };
     return this;
   }
+  // ═══ NUDGE ═══
+  /** Disable nudge messages */
   noNudge() {
     this.form.nudge = { ...this.form.nudge, enabled: false };
     return this;
   }
+  /** Set inactivity hours before nudge */
   nudgeAfter(hours) {
     this.form.nudge = { ...this.form.nudge, afterInactiveHours: hours };
     return this;
   }
+  /** Set custom nudge message */
   nudgeMessage(message) {
     this.form.nudge = { ...this.form.nudge, message };
     return this;
   }
+  // ═══ HOOKS ═══
+  // WHY hooks: Allow consuming plugins to handle form events
+  /** Set task worker to call on session start */
   onStart(workerName) {
     this.form.hooks = { ...this.form.hooks, onStart: workerName };
     return this;
   }
+  /** Set task worker to call on field change */
   onFieldChange(workerName) {
     this.form.hooks = { ...this.form.hooks, onFieldChange: workerName };
     return this;
   }
+  /** Set task worker to call when form is ready to submit */
   onReady(workerName) {
     this.form.hooks = { ...this.form.hooks, onReady: workerName };
     return this;
   }
+  /** Set task worker to call on submission */
   onSubmit(workerName) {
     this.form.hooks = { ...this.form.hooks, onSubmit: workerName };
     return this;
   }
+  /** Set task worker to call on cancellation */
   onCancel(workerName) {
     this.form.hooks = { ...this.form.hooks, onCancel: workerName };
     return this;
   }
+  /** Set task worker to call on expiration */
   onExpire(workerName) {
     this.form.hooks = { ...this.form.hooks, onExpire: workerName };
     return this;
   }
+  /** Set multiple hooks at once */
   hooks(hooks) {
     this.form.hooks = { ...this.form.hooks, ...hooks };
     return this;
   }
+  // ═══ DEBUG ═══
+  /** Enable debug mode (logs extraction reasoning) */
   debug() {
     this.form.debug = true;
     return this;
   }
+  // ═══ I18N ═══
+  /** Add localized form text */
   i18n(locale, translations) {
     this.form.i18n = { ...this.form.i18n, [locale]: translations };
     return this;
   }
+  // ═══ META ═══
+  /** Add custom metadata */
   meta(key, value) {
     this.form.meta = { ...this.form.meta, [key]: value };
     return this;
   }
+  // ═══ BUILD ═══
+  /**
+   * Build the final FormDefinition.
+   *
+   * Applies defaults and validates the form.
+   *
+   * @returns Complete FormDefinition object
+   */
   build() {
     const form = {
       id: this.form.id,
@@ -3075,132 +629,42 @@ class FormBuilder {
     };
     return form;
   }
-}
+};
 var Form = FormBuilder;
 var C = ControlBuilder;
 function prettify2(key) {
   return key.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 
-// index.ts
-init_service();
-init_restore();
-init_extractor();
-init_context();
-
-// src/tasks/nudge.ts
-import { logger as logger5 } from "@elizaos/core";
-var formNudgeWorker = {
-  name: "form_nudge_check",
-  validate: async (_runtime, _message, _state) => {
-    return true;
-  },
-  execute: async (runtime, _options, _task) => {
-    try {
-      const formService = runtime.getService("FORM");
-      if (!formService) {
-        logger5.debug("[FormNudge] Form service not available");
-        return;
-      }
-      logger5.debug("[FormNudge] Nudge check cycle completed");
-    } catch (error) {
-      logger5.error("[FormNudge] Error during nudge check:", String(error));
-    }
-  }
-};
-async function processEntityNudges(runtime, entityId) {
-  const formService = runtime.getService("FORM");
-  if (!formService)
-    return;
-  const activeSessions = await formService.getAllActiveSessions(entityId);
-  const stashedSessions = await formService.getStashedSessions(entityId);
-  const allSessions = [...activeSessions, ...stashedSessions];
-  const now = Date.now();
-  const expirationWarningMs = 24 * 60 * 60 * 1000;
-  for (const session of allSessions) {
-    const form = formService.getForm(session.formId);
-    if (session.expiresAt < now) {
-      session.status = "expired";
-      await formService.saveSession(session);
-      if (form?.hooks?.onExpire) {
-        const worker = runtime.getTaskWorker(form.hooks.onExpire);
-        if (worker) {
-          try {
-            await worker.execute(runtime, { session, form }, {});
-          } catch (error) {
-            logger5.error("[FormNudge] onExpire hook failed:", String(error));
-          }
-        }
-      }
-      logger5.debug(`[FormNudge] Session ${session.id} expired`);
-      continue;
-    }
-    if (isExpiringSoon(session, expirationWarningMs) && !session.expirationWarned) {
-      await sendExpirationWarning(runtime, session, form);
-      session.expirationWarned = true;
-      await formService.saveSession(session);
-      continue;
-    }
-    if (session.status === "stashed" && shouldNudge(session, form)) {
-      await sendNudge(runtime, session, form);
-      session.nudgeCount = (session.nudgeCount || 0) + 1;
-      session.lastNudgeAt = now;
-      await formService.saveSession(session);
-    }
-  }
-}
-async function sendNudge(runtime, session, form) {
-  const message = form?.nudge?.message || `You have an unfinished "${form?.name || "form"}". Would you like to continue?`;
-  try {
-    if (typeof runtime.sendMessageToRoom === "function") {
-      await runtime.sendMessageToRoom(session.roomId, {
-        text: message
-      });
-      logger5.debug(`[FormNudge] Sent nudge for session in room ${session.roomId}`);
-    }
-  } catch (error) {
-    logger5.error("[FormNudge] Failed to send nudge:", String(error));
-  }
-}
-async function sendExpirationWarning(runtime, session, form) {
-  const remaining = formatTimeRemaining(session);
-  const message = `Your "${form?.name || "form"}" form will expire in ${remaining}. Say "resume" to keep working on it.`;
-  try {
-    if (typeof runtime.sendMessageToRoom === "function") {
-      await runtime.sendMessageToRoom(session.roomId, {
-        text: message
-      });
-      logger5.debug(`[FormNudge] Sent expiration warning for session in room ${session.roomId}`);
-    }
-  } catch (error) {
-    logger5.error("[FormNudge] Failed to send expiration warning:", String(error));
-  }
-}
-
-// index.ts
+// src/index.ts
 var formPlugin = {
   name: "form",
   description: "Agent-native conversational forms for data collection",
+  // Service for form management
   services: [
+    // FormService is registered as a static class
+    // It will be instantiated by the runtime
     {
       serviceType: "FORM",
       start: async (runtime) => {
-        const { FormService: FormService2 } = await Promise.resolve().then(() => (init_service(), exports_service));
+        const { FormService: FormService2 } = await import("./service-TCCXKV3T.js");
         return FormService2.start(runtime);
       }
     }
   ],
+  // Provider for form context
   providers: [
+    // Import dynamically to avoid circular deps
     {
       name: "FORM_CONTEXT",
       description: "Provides context about active form sessions",
-      dynamic: true,
       get: async (runtime, message, state) => {
-        const { formContextProvider: formContextProvider2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+        const { formContextProvider: formContextProvider2 } = await import("./context-MHPFYZZ2.js");
         return formContextProvider2.get(runtime, message, state);
       }
     }
   ],
+  // Evaluator for field extraction
   evaluators: [
     {
       name: "form_evaluator",
@@ -3208,26 +672,27 @@ var formPlugin = {
       similes: ["FORM_EXTRACTION", "FORM_HANDLER"],
       examples: [],
       validate: async (runtime, message, state) => {
-        const { formEvaluator: formEvaluator2 } = await Promise.resolve().then(() => (init_extractor(), exports_extractor));
+        const { formEvaluator: formEvaluator2 } = await import("./extractor-UWASKXKD.js");
         return formEvaluator2.validate(runtime, message, state);
       },
       handler: async (runtime, message, state) => {
-        const { formEvaluator: formEvaluator2 } = await Promise.resolve().then(() => (init_extractor(), exports_extractor));
+        const { formEvaluator: formEvaluator2 } = await import("./extractor-UWASKXKD.js");
         return formEvaluator2.handler(runtime, message, state);
       }
     }
   ],
+  // Action for restoring stashed forms
   actions: [
     {
       name: "FORM_RESTORE",
       similes: ["RESUME_FORM", "CONTINUE_FORM"],
       description: "Restore a previously stashed form session",
       validate: async (runtime, message, state) => {
-        const { formRestoreAction: formRestoreAction2 } = await Promise.resolve().then(() => (init_restore(), exports_restore));
+        const { formRestoreAction: formRestoreAction2 } = await import("./restore-S7JLME4H.js");
         return formRestoreAction2.validate(runtime, message, state);
       },
       handler: async (runtime, message, state, options, callback) => {
-        const { formRestoreAction: formRestoreAction2 } = await Promise.resolve().then(() => (init_restore(), exports_restore));
+        const { formRestoreAction: formRestoreAction2 } = await import("./restore-S7JLME4H.js");
         return formRestoreAction2.handler(runtime, message, state, options, callback);
       },
       examples: [
@@ -3247,63 +712,197 @@ var formPlugin = {
     }
   ]
 };
-var typescript_default = formPlugin;
+var index_default = formPlugin;
 export {
-  validateField,
-  shouldNudge,
-  shouldConfirmCancel,
-  saveSubmission,
-  saveSession,
-  saveAutofillData,
-  registerTypeHandler,
-  registerBuiltinTypes,
-  quickIntentDetect,
-  processEntityNudges,
-  prettify,
-  parseValue,
-  matchesMimeType,
-  llmIntentAndExtract,
-  isUXIntent,
-  isLifecycleIntent,
-  isExpiringSoon,
-  isExpired,
-  isBuiltinType,
-  hasDataToExtract,
-  getTypeHandler,
-  getSubmissions,
-  getStashedSessions,
-  getBuiltinType,
-  getAutofillData,
-  getAllActiveSessions,
-  getActiveSession,
-  formatValue,
-  formatTimeRemaining,
-  formatEffort,
-  formRestoreAction,
-  formPlugin,
-  formNudgeWorker,
-  formEvaluator,
-  formContextProvider,
-  extractSingleField,
-  detectCorrection,
-  deleteSession,
-  typescript_default as default,
-  clearTypeHandlers,
-  calculateTTL,
-  applyFormDefaults,
-  applyControlDefaults,
-  FormService,
-  FormBuilder,
-  Form,
-  FORM_SUBMISSION_COMPONENT,
-  FORM_SESSION_COMPONENT,
-  FORM_DEFINITION_DEFAULTS,
-  FORM_CONTROL_DEFAULTS,
-  FORM_AUTOFILL_COMPONENT,
-  ControlBuilder,
-  C,
+  BUILTIN_TYPES,
   BUILTIN_TYPE_MAP,
-  BUILTIN_TYPES
+  C,
+  ControlBuilder,
+  FORM_AUTOFILL_COMPONENT,
+  FORM_CONTROL_DEFAULTS,
+  FORM_DEFINITION_DEFAULTS,
+  FORM_SESSION_COMPONENT,
+  FORM_SUBMISSION_COMPONENT,
+  Form,
+  FormBuilder,
+  FormService,
+  applyControlDefaults,
+  applyFormDefaults,
+  calculateTTL,
+  clearTypeHandlers,
+  index_default as default,
+  deleteSession,
+  detectCorrection,
+  extractSingleField,
+  formContextProvider,
+  formEvaluator,
+  formPlugin,
+  formRestoreAction,
+  formatEffort,
+  formatTimeRemaining,
+  formatValue,
+  getActiveSession,
+  getAllActiveSessions,
+  getAutofillData,
+  getBuiltinType,
+  getStashedSessions,
+  getSubmissions,
+  getTypeHandler,
+  hasDataToExtract,
+  isBuiltinType,
+  isExpired,
+  isExpiringSoon,
+  isLifecycleIntent,
+  isUXIntent,
+  llmIntentAndExtract,
+  matchesMimeType,
+  parseValue,
+  prettify,
+  quickIntentDetect,
+  registerBuiltinTypes,
+  registerTypeHandler,
+  saveAutofillData,
+  saveSession,
+  saveSubmission,
+  shouldConfirmCancel,
+  shouldNudge,
+  validateField
 };
-
-//# debugId=DC90FD3CDE2C7E4764756E2164756E21
+/**
+ * @module @elizaos/plugin-form
+ * @description Guardrails for agent-guided user journeys
+ *
+ * @author Odilitime
+ * @copyright 2025 Odilitime
+ * @license MIT
+ *
+ * ## The Core Insight
+ *
+ * Forms aren't just about data collection - they're **guardrails for agents**.
+ *
+ * Without structure, agents wander. They forget context, miss required
+ * information, and can't reliably guide users to outcomes. This plugin
+ * gives agents the tools to follow conventions and shepherd users through
+ * structured journeys - registrations, orders, applications, onboarding flows.
+ *
+ * **Forms define the path. Agents follow it. Users reach outcomes.**
+ *
+ * ## Key Features
+ *
+ * - **Natural Language Extraction**: "I'm John, 25, john@example.com"
+ * - **Two-Tier Intent Detection**: Fast English keywords + LLM fallback
+ * - **UX Magic**: Undo, skip, explain, example, progress, autofill
+ * - **Smart TTL**: Retention scales with user effort
+ * - **Fluent Builder API**: Type-safe form definitions
+ * - **Extensible Types**: Register custom field types
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                        Form Plugin                          │
+ * ├─────────────────────────────────────────────────────────────┤
+ * │                                                             │
+ * │   Provider (FORM_CONTEXT)                                   │
+ * │   - Runs BEFORE agent responds                              │
+ * │   - Injects form state into context                         │
+ * │   - Tells agent what to ask next                            │
+ * │                                                             │
+ * │   Evaluator (form_evaluator)                                │
+ * │   - Runs AFTER each user message                            │
+ * │   - Detects intent (submit, cancel, undo, etc.)             │
+ * │   - Extracts field values from natural language             │
+ * │   - Updates session state                                   │
+ * │                                                             │
+ * │   Action (FORM_RESTORE)                                     │
+ * │   - Preempts REPLY for restore intent                       │
+ * │   - Immediately restores stashed forms                      │
+ * │                                                             │
+ * │   Service (FormService)                                     │
+ * │   - Manages form definitions                                │
+ * │   - Manages sessions, submissions, autofill                 │
+ * │   - Executes lifecycle hooks                                │
+ * │                                                             │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Quick Start
+ *
+ * ### 1. Add plugin to your agent
+ *
+ * ```typescript
+ * import { formPlugin } from '@elizaos/plugin-form';
+ *
+ * const agent = {
+ *   plugins: [formPlugin, ...otherPlugins],
+ * };
+ * ```
+ *
+ * ### 2. Define a form
+ *
+ * ```typescript
+ * import { Form, C } from '@elizaos/plugin-form';
+ *
+ * const registrationForm = Form.create('registration')
+ *   .name('User Registration')
+ *   .control(C.email('email').required().ask('What email should we use?'))
+ *   .control(C.text('name').required().ask("What's your name?"))
+ *   .control(C.number('age').min(13))
+ *   .onSubmit('handle_registration')
+ *   .build();
+ * ```
+ *
+ * ### 3. Register and start
+ *
+ * ```typescript
+ * // In your plugin init:
+ * const formService = runtime.getService('FORM') as FormService;
+ * formService.registerForm(registrationForm);
+ *
+ * // When you need to collect data:
+ * await formService.startSession('registration', entityId, roomId);
+ * ```
+ *
+ * ### 4. Handle submissions
+ *
+ * ```typescript
+ * runtime.registerTaskWorker({
+ *   name: 'handle_registration',
+ *   execute: async (runtime, options) => {
+ *     const { submission } = options;
+ *     const { email, name, age } = submission.values;
+ *     // Create user account, etc.
+ *   }
+ * });
+ * ```
+ *
+ * ## User Experience
+ *
+ * The form plugin handles these user interactions:
+ *
+ * | User Says | Intent | Result |
+ * |-----------|--------|--------|
+ * | "I'm John, 25 years old" | fill_form | Extract name=John, age=25 |
+ * | "done" / "submit" | submit | Submit the form |
+ * | "save for later" | stash | Save and switch contexts |
+ * | "resume my form" | restore | Restore stashed form |
+ * | "cancel" / "nevermind" | cancel | Abandon form |
+ * | "undo" / "go back" | undo | Revert last change |
+ * | "skip" | skip | Skip optional field |
+ * | "why?" | explain | Explain current field |
+ * | "example?" | example | Show example value |
+ * | "how far?" | progress | Show completion status |
+ * | "same as last time" | autofill | Use saved values |
+ *
+ * ## Module Exports
+ *
+ * - **Types**: FormControl, FormDefinition, FormSession, etc.
+ * - **Builder**: Form, C (ControlBuilder)
+ * - **Service**: FormService
+ * - **Utilities**: validateField, parseValue, formatValue
+ * - **Plugin**: formPlugin (default export)
+ *
+ * @see {@link FormService} for form management API
+ * @see {@link FormBuilder} for fluent form definition
+ * @see {@link ControlBuilder} for field definition
+ */