@elizaos/plugin-form 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.js

@@ -0,0 +1,3293 @@
+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());
+    }
+    registerType(type, handler) {
+      registerTypeHandler(type, handler);
+      logger.debug(`[FormService] Registered type handler: ${type}`);
+    }
+    getTypeHandler(type) {
+      return getTypeHandler(type);
+    }
+    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
+        };
+        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) => {
+      try {
+        const text = message.content?.text || "";
+        const intent = quickIntentDetect(text);
+        if (intent !== "restore") {
+          return false;
+        }
+        const formService = runtime.getService("FORM");
+        if (!formService) {
+          return false;
+        }
+        const entityId = message.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;
+      }
+    },
+    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",
+    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();
+
+// 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 effortDays = minutesSpent * multiplier;
+  const ttlDays = Math.min(maxDays, Math.max(minDays, effortDays));
+  return Date.now() + ttlDays * 24 * 60 * 60 * 1000;
+}
+function shouldNudge(session, form) {
+  const nudgeConfig = form?.nudge;
+  if (nudgeConfig?.enabled === false) {
+    return false;
+  }
+  const maxNudges = nudgeConfig?.maxNudges ?? FORM_DEFINITION_DEFAULTS.nudge.maxNudges;
+  if ((session.nudgeCount || 0) >= maxNudges) {
+    return false;
+  }
+  const afterInactiveHours = nudgeConfig?.afterInactiveHours ?? FORM_DEFINITION_DEFAULTS.nudge.afterInactiveHours;
+  const inactiveMs = afterInactiveHours * 60 * 60 * 1000;
+  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) {
+      return false;
+    }
+  }
+  return true;
+}
+function isExpiringSoon(session, withinMs) {
+  return session.expiresAt - Date.now() < withinMs;
+}
+function isExpired(session) {
+  return session.expiresAt < Date.now();
+}
+function shouldConfirmCancel(session) {
+  const minEffortMs = 5 * 60 * 1000;
+  return session.effort.timeSpentMs > minEffortMs;
+}
+function formatTimeRemaining(session) {
+  const remaining = session.expiresAt - Date.now();
+  if (remaining <= 0) {
+    return "expired";
+  }
+  const hours = Math.floor(remaining / (60 * 60 * 1000));
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days} day${days > 1 ? "s" : ""}`;
+  }
+  if (hours > 0) {
+    return `${hours} hour${hours > 1 ? "s" : ""}`;
+  }
+  const minutes = Math.floor(remaining / (60 * 1000));
+  return `${minutes} minute${minutes > 1 ? "s" : ""}`;
+}
+function formatEffort(session) {
+  const minutes = Math.floor(session.effort.timeSpentMs / 60000);
+  if (minutes < 1) {
+    return "just started";
+  }
+  if (minutes < 60) {
+    return `${minutes} minute${minutes > 1 ? "s" : ""}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (remainingMinutes === 0) {
+    return `${hours} hour${hours > 1 ? "s" : ""}`;
+  }
+  return `${hours}h ${remainingMinutes}m`;
+}
+// src/defaults.ts
+init_types();
+function applyControlDefaults(control) {
+  return {
+    key: control.key,
+    label: control.label || prettify(control.key),
+    type: control.type || FORM_CONTROL_DEFAULTS.type,
+    required: control.required ?? FORM_CONTROL_DEFAULTS.required,
+    confirmThreshold: control.confirmThreshold ?? FORM_CONTROL_DEFAULTS.confirmThreshold,
+    ...control
+  };
+}
+function applyFormDefaults(form) {
+  return {
+    id: form.id,
+    name: form.name || prettify(form.id),
+    version: form.version ?? FORM_DEFINITION_DEFAULTS.version,
+    status: form.status ?? FORM_DEFINITION_DEFAULTS.status,
+    controls: (form.controls || []).map(applyControlDefaults),
+    ux: {
+      allowUndo: form.ux?.allowUndo ?? FORM_DEFINITION_DEFAULTS.ux.allowUndo,
+      allowSkip: form.ux?.allowSkip ?? FORM_DEFINITION_DEFAULTS.ux.allowSkip,
+      maxUndoSteps: form.ux?.maxUndoSteps ?? FORM_DEFINITION_DEFAULTS.ux.maxUndoSteps,
+      showExamples: form.ux?.showExamples ?? FORM_DEFINITION_DEFAULTS.ux.showExamples,
+      showExplanations: form.ux?.showExplanations ?? FORM_DEFINITION_DEFAULTS.ux.showExplanations,
+      allowAutofill: form.ux?.allowAutofill ?? FORM_DEFINITION_DEFAULTS.ux.allowAutofill
+    },
+    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: {
+      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: form.debug ?? FORM_DEFINITION_DEFAULTS.debug,
+    ...form
+  };
+}
+function prettify(key) {
+  return key.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+// src/builder.ts
+class ControlBuilder {
+  control;
+  constructor(key) {
+    this.control = { key };
+  }
+  static field(key) {
+    return new ControlBuilder(key);
+  }
+  static text(key) {
+    return new ControlBuilder(key).type("text");
+  }
+  static email(key) {
+    return new ControlBuilder(key).type("email");
+  }
+  static number(key) {
+    return new ControlBuilder(key).type("number");
+  }
+  static boolean(key) {
+    return new ControlBuilder(key).type("boolean");
+  }
+  static select(key, options) {
+    return new ControlBuilder(key).type("select").options(options);
+  }
+  static date(key) {
+    return new ControlBuilder(key).type("date");
+  }
+  static file(key) {
+    return new ControlBuilder(key).type("file");
+  }
+  type(type) {
+    this.control.type = type;
+    return this;
+  }
+  required() {
+    this.control.required = true;
+    return this;
+  }
+  optional() {
+    this.control.required = false;
+    return this;
+  }
+  hidden() {
+    this.control.hidden = true;
+    return this;
+  }
+  sensitive() {
+    this.control.sensitive = true;
+    return this;
+  }
+  readonly() {
+    this.control.readonly = true;
+    return this;
+  }
+  multiple() {
+    this.control.multiple = true;
+    return this;
+  }
+  pattern(regex) {
+    this.control.pattern = regex;
+    return this;
+  }
+  min(n) {
+    this.control.min = n;
+    return this;
+  }
+  max(n) {
+    this.control.max = n;
+    return this;
+  }
+  minLength(n) {
+    this.control.minLength = n;
+    return this;
+  }
+  maxLength(n) {
+    this.control.maxLength = n;
+    return this;
+  }
+  enum(values) {
+    this.control.enum = values;
+    return this;
+  }
+  options(opts) {
+    this.control.options = opts;
+    return this;
+  }
+  label(label) {
+    this.control.label = label;
+    return this;
+  }
+  ask(prompt) {
+    this.control.askPrompt = prompt;
+    return this;
+  }
+  description(desc) {
+    this.control.description = desc;
+    return this;
+  }
+  hint(...hints) {
+    this.control.extractHints = hints;
+    return this;
+  }
+  example(value) {
+    this.control.example = value;
+    return this;
+  }
+  confirmThreshold(n) {
+    this.control.confirmThreshold = n;
+    return this;
+  }
+  accept(mimeTypes) {
+    this.control.file = { ...this.control.file, accept: mimeTypes };
+    return this;
+  }
+  maxSize(bytes) {
+    this.control.file = { ...this.control.file, maxSize: bytes };
+    return this;
+  }
+  maxFiles(n) {
+    this.control.file = { ...this.control.file, maxFiles: n };
+    return this;
+  }
+  roles(...roles) {
+    this.control.roles = roles;
+    return this;
+  }
+  default(value) {
+    this.control.defaultValue = value;
+    return this;
+  }
+  dependsOn(field, condition = "exists", value) {
+    this.control.dependsOn = { field, condition, value };
+    return this;
+  }
+  dbbind(columnName) {
+    this.control.dbbind = columnName;
+    return this;
+  }
+  section(name) {
+    this.control.ui = { ...this.control.ui, section: name };
+    return this;
+  }
+  order(n) {
+    this.control.ui = { ...this.control.ui, order: n };
+    return this;
+  }
+  placeholder(text) {
+    this.control.ui = { ...this.control.ui, placeholder: text };
+    return this;
+  }
+  helpText(text) {
+    this.control.ui = { ...this.control.ui, helpText: text };
+    return this;
+  }
+  widget(type) {
+    this.control.ui = { ...this.control.ui, widget: type };
+    return this;
+  }
+  i18n(locale, translations) {
+    this.control.i18n = { ...this.control.i18n, [locale]: translations };
+    return this;
+  }
+  meta(key, value) {
+    this.control.meta = { ...this.control.meta, [key]: value };
+    return this;
+  }
+  build() {
+    const control = {
+      key: this.control.key,
+      label: this.control.label || prettify2(this.control.key),
+      type: this.control.type || "text",
+      ...this.control
+    };
+    return control;
+  }
+}
+
+class FormBuilder {
+  form;
+  constructor(id) {
+    this.form = { id, controls: [] };
+  }
+  static create(id) {
+    return new FormBuilder(id);
+  }
+  name(name) {
+    this.form.name = name;
+    return this;
+  }
+  description(desc) {
+    this.form.description = desc;
+    return this;
+  }
+  version(v) {
+    this.form.version = v;
+    return this;
+  }
+  control(builder) {
+    const ctrl = builder instanceof ControlBuilder ? builder.build() : builder;
+    this.form.controls?.push(ctrl);
+    return this;
+  }
+  controls(...builders) {
+    for (const builder of builders) {
+      this.control(builder);
+    }
+    return this;
+  }
+  required(...keys) {
+    for (const key of keys) {
+      this.control(ControlBuilder.field(key).required());
+    }
+    return this;
+  }
+  optional(...keys) {
+    for (const key of keys) {
+      this.control(ControlBuilder.field(key));
+    }
+    return this;
+  }
+  roles(...roles) {
+    this.form.roles = roles;
+    return this;
+  }
+  allowMultiple() {
+    this.form.allowMultiple = true;
+    return this;
+  }
+  noUndo() {
+    this.form.ux = { ...this.form.ux, allowUndo: false };
+    return this;
+  }
+  noSkip() {
+    this.form.ux = { ...this.form.ux, allowSkip: false };
+    return this;
+  }
+  noAutofill() {
+    this.form.ux = { ...this.form.ux, allowAutofill: false };
+    return this;
+  }
+  maxUndoSteps(n) {
+    this.form.ux = { ...this.form.ux, maxUndoSteps: n };
+    return this;
+  }
+  ttl(config) {
+    this.form.ttl = { ...this.form.ttl, ...config };
+    return this;
+  }
+  noNudge() {
+    this.form.nudge = { ...this.form.nudge, enabled: false };
+    return this;
+  }
+  nudgeAfter(hours) {
+    this.form.nudge = { ...this.form.nudge, afterInactiveHours: hours };
+    return this;
+  }
+  nudgeMessage(message) {
+    this.form.nudge = { ...this.form.nudge, message };
+    return this;
+  }
+  onStart(workerName) {
+    this.form.hooks = { ...this.form.hooks, onStart: workerName };
+    return this;
+  }
+  onFieldChange(workerName) {
+    this.form.hooks = { ...this.form.hooks, onFieldChange: workerName };
+    return this;
+  }
+  onReady(workerName) {
+    this.form.hooks = { ...this.form.hooks, onReady: workerName };
+    return this;
+  }
+  onSubmit(workerName) {
+    this.form.hooks = { ...this.form.hooks, onSubmit: workerName };
+    return this;
+  }
+  onCancel(workerName) {
+    this.form.hooks = { ...this.form.hooks, onCancel: workerName };
+    return this;
+  }
+  onExpire(workerName) {
+    this.form.hooks = { ...this.form.hooks, onExpire: workerName };
+    return this;
+  }
+  hooks(hooks) {
+    this.form.hooks = { ...this.form.hooks, ...hooks };
+    return this;
+  }
+  debug() {
+    this.form.debug = true;
+    return this;
+  }
+  i18n(locale, translations) {
+    this.form.i18n = { ...this.form.i18n, [locale]: translations };
+    return this;
+  }
+  meta(key, value) {
+    this.form.meta = { ...this.form.meta, [key]: value };
+    return this;
+  }
+  build() {
+    const form = {
+      id: this.form.id,
+      name: this.form.name || prettify2(this.form.id),
+      controls: this.form.controls || [],
+      ...this.form
+    };
+    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
+var formPlugin = {
+  name: "form",
+  description: "Agent-native conversational forms for data collection",
+  services: [
+    {
+      serviceType: "FORM",
+      start: async (runtime) => {
+        const { FormService: FormService2 } = await Promise.resolve().then(() => (init_service(), exports_service));
+        return FormService2.start(runtime);
+      }
+    }
+  ],
+  providers: [
+    {
+      name: "FORM_CONTEXT",
+      description: "Provides context about active form sessions",
+      get: async (runtime, message, state) => {
+        const { formContextProvider: formContextProvider2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+        return formContextProvider2.get(runtime, message, state);
+      }
+    }
+  ],
+  evaluators: [
+    {
+      name: "form_evaluator",
+      description: "Extracts form fields and handles form intents",
+      similes: ["FORM_EXTRACTION", "FORM_HANDLER"],
+      examples: [],
+      validate: async (runtime, message, state) => {
+        const { formEvaluator: formEvaluator2 } = await Promise.resolve().then(() => (init_extractor(), exports_extractor));
+        return formEvaluator2.validate(runtime, message, state);
+      },
+      handler: async (runtime, message, state) => {
+        const { formEvaluator: formEvaluator2 } = await Promise.resolve().then(() => (init_extractor(), exports_extractor));
+        return formEvaluator2.handler(runtime, message, state);
+      }
+    }
+  ],
+  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));
+        return formRestoreAction2.validate(runtime, message, state);
+      },
+      handler: async (runtime, message, state, options, callback) => {
+        const { formRestoreAction: formRestoreAction2 } = await Promise.resolve().then(() => (init_restore(), exports_restore));
+        return formRestoreAction2.handler(runtime, message, state, options, callback);
+      },
+      examples: [
+        [
+          {
+            name: "{{user1}}",
+            content: { text: "Resume my form" }
+          },
+          {
+            name: "{{agentName}}",
+            content: {
+              text: "I've restored your form. Let's continue where you left off."
+            }
+          }
+        ]
+      ]
+    }
+  ]
+};
+var typescript_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_TYPE_MAP,
+  BUILTIN_TYPES
+};
+
+//# debugId=D9CCEBB86B648A7B64756E2164756E21
+//# sourceMappingURL=index.js.map