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

package/dist/chunk-TBCL2ILB.js

@@ -0,0 +1,172 @@
+import {
+  quickIntentDetect
+} from "./chunk-YTWANJ3R.js";
+
+// src/actions/restore.ts
+import {
+  logger
+} from "@elizaos/core";
+var formRestoreAction = {
+  name: "FORM_RESTORE",
+  similes: ["RESUME_FORM", "CONTINUE_FORM"],
+  description: "Restore a previously stashed form session",
+  /**
+   * Validate: Only trigger for restore intent with stashed sessions.
+   *
+   * Fast path: Uses quickIntentDetect for English keywords.
+   * Evaluator handles non-English via LLM.
+   *
+   * @returns true if action should run
+   */
+  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) {
+      logger.error("[FormRestoreAction] Validation error:", String(error));
+      return false;
+    }
+  },
+  /**
+   * Handler: Restore the most recent stashed session.
+   *
+   * 1. Check for conflicts (active session in room)
+   * 2. Restore the session
+   * 3. Generate summary response
+   *
+   * @returns ActionResult with success status and session data
+   */
+  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 += `\u2022 ${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) {
+      logger.error("[FormRestoreAction] Handler error:", String(error));
+      await callback?.({
+        text: "Sorry, I couldn't restore your form. Please try again."
+      });
+      return { success: false };
+    }
+  },
+  // Example conversations for training/documentation
+  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..."
+        }
+      }
+    ]
+  ]
+};
+var restore_default = formRestoreAction;
+
+export {
+  formRestoreAction,
+  restore_default
+};

package/dist/chunk-WY4WK3HD.js

@@ -0,0 +1,57 @@
+// src/template.ts
+var TEMPLATE_PATTERN = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+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 !== void 0 ? 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
+  };
+}
+
+export {
+  buildTemplateValues,
+  renderTemplate,
+  resolveControlTemplates
+};