@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-capabilities/experience/types.d.ts

@@ -0,0 +1,90 @@
+import type { Memory } from "../../../types/memory.ts";
+import type { UUID } from "../../../types/primitives.ts";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+declare module "../../../types/service.ts" {
+    interface ServiceTypeRegistry {
+        EXPERIENCE: "EXPERIENCE";
+    }
+}
+export declare const ExperienceServiceType: {
+    EXPERIENCE: "EXPERIENCE";
+};
+export declare enum ExperienceType {
+    SUCCESS = "success",// Agent accomplished something
+    FAILURE = "failure",// Agent failed at something
+    DISCOVERY = "discovery",// Agent discovered new information
+    CORRECTION = "correction",// Agent corrected a mistake
+    LEARNING = "learning",// Agent learned something new
+    HYPOTHESIS = "hypothesis",// Agent formed a hypothesis
+    VALIDATION = "validation",// Agent validated a hypothesis
+    WARNING = "warning"
+}
+export declare enum OutcomeType {
+    POSITIVE = "positive",
+    NEGATIVE = "negative",
+    NEUTRAL = "neutral",
+    MIXED = "mixed"
+}
+export interface Experience {
+    id: UUID;
+    agentId: UUID;
+    type: ExperienceType;
+    outcome: OutcomeType;
+    context: string;
+    action: string;
+    result: string;
+    learning: string;
+    tags: string[];
+    domain: string;
+    relatedExperiences?: UUID[];
+    supersedes?: UUID;
+    confidence: number;
+    importance: number;
+    createdAt: number;
+    updatedAt: number;
+    lastAccessedAt?: number;
+    accessCount: number;
+    previousBelief?: string;
+    correctedBelief?: string;
+    embedding?: number[];
+    memoryIds?: UUID[];
+}
+export interface ExperienceQuery {
+    query?: string;
+    type?: ExperienceType | ExperienceType[];
+    outcome?: OutcomeType | OutcomeType[];
+    domain?: string | string[];
+    tags?: string[];
+    minImportance?: number;
+    minConfidence?: number;
+    timeRange?: {
+        start?: number;
+        end?: number;
+    };
+    limit?: number;
+    includeRelated?: boolean;
+}
+export interface ExperienceAnalysis {
+    pattern?: string;
+    frequency?: number;
+    reliability?: number;
+    alternatives?: string[];
+    recommendations?: string[];
+}
+export interface ExperienceEvent {
+    experienceId: UUID;
+    eventType: "created" | "accessed" | "updated" | "superseded";
+    timestamp: number;
+    metadata?: JsonObject;
+}
+export interface ExperienceMemory extends Memory {
+    experienceId: string;
+    experienceType: ExperienceType;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/experience/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/types.ts"],"names":[],"mappings":"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"}

package/packages/typescript/src/features/advanced-capabilities/experience/types.js

@@ -0,0 +1,22 @@
+// Export service type constant
+export const ExperienceServiceType = {
+    EXPERIENCE: "EXPERIENCE",
+};
+export var ExperienceType;
+(function (ExperienceType) {
+    ExperienceType["SUCCESS"] = "success";
+    ExperienceType["FAILURE"] = "failure";
+    ExperienceType["DISCOVERY"] = "discovery";
+    ExperienceType["CORRECTION"] = "correction";
+    ExperienceType["LEARNING"] = "learning";
+    ExperienceType["HYPOTHESIS"] = "hypothesis";
+    ExperienceType["VALIDATION"] = "validation";
+    ExperienceType["WARNING"] = "warning";
+})(ExperienceType || (ExperienceType = {}));
+export var OutcomeType;
+(function (OutcomeType) {
+    OutcomeType["POSITIVE"] = "positive";
+    OutcomeType["NEGATIVE"] = "negative";
+    OutcomeType["NEUTRAL"] = "neutral";
+    OutcomeType["MIXED"] = "mixed";
+})(OutcomeType || (OutcomeType = {}));

package/packages/typescript/src/features/advanced-capabilities/experience/utils/confidenceDecay.d.ts

@@ -0,0 +1,34 @@
+import type { Experience } from "../types";
+export interface DecayConfig {
+    halfLife: number;
+    minConfidence: number;
+    decayStartDelay: number;
+}
+export declare class ConfidenceDecayManager {
+    private config;
+    constructor(config?: Partial<DecayConfig>);
+    /**
+     * Calculate the decayed confidence for an experience
+     */
+    getDecayedConfidence(experience: Experience): number;
+    /**
+     * Get experiences that need reinforcement (low confidence due to decay)
+     */
+    getExperiencesNeedingReinforcement(experiences: Experience[], threshold?: number): Experience[];
+    /**
+     * Calculate reinforcement boost when an experience is validated
+     */
+    calculateReinforcementBoost(experience: Experience, validationStrength?: number): number;
+    /**
+     * Adjust decay rate based on experience type and domain
+     */
+    getDomainSpecificDecay(experience: Experience): DecayConfig;
+    /**
+     * Get confidence trend for an experience over time
+     */
+    getConfidenceTrend(experience: Experience, points?: number): Array<{
+        timestamp: number;
+        confidence: number;
+    }>;
+}
+//# sourceMappingURL=confidenceDecay.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/experience/utils/confidenceDecay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidenceDecay.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/utils/confidenceDecay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,MAAM,WAAW,WAAW;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACxB;AAQD,qBAAa,sBAAsB;IAClC,OAAO,CAAC,MAAM,CAAc;gBAEhB,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;IAI7C;;OAEG;IACH,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;IAoBpD;;OAEG;IACH,kCAAkC,CACjC,WAAW,EAAE,UAAU,EAAE,EACzB,SAAS,SAAM,GACb,UAAU,EAAE;IAOf;;OAEG;IACH,2BAA2B,CAC1B,UAAU,EAAE,UAAU,EACtB,kBAAkB,SAAM,GACtB,MAAM;IAMT;;OAEG;IACH,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,WAAW;IAsC3D;;OAEG;IACH,kBAAkB,CACjB,UAAU,EAAE,UAAU,EACtB,MAAM,SAAK,GACT,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CA6BnD"}

package/packages/typescript/src/features/advanced-capabilities/experience/utils/confidenceDecay.js

@@ -0,0 +1,106 @@
+import { ExperienceType } from "../types";
+const DEFAULT_DECAY_CONFIG = {
+    halfLife: 30 * 24 * 60 * 60 * 1000, // 30 days
+    minConfidence: 0.1, // 10% minimum
+    decayStartDelay: 7 * 24 * 60 * 60 * 1000, // 7 days grace period
+};
+export class ConfidenceDecayManager {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
+    }
+    /**
+     * Calculate the decayed confidence for an experience
+     */
+    getDecayedConfidence(experience) {
+        const now = Date.now();
+        const age = now - experience.createdAt;
+        const specificConfig = this.getDomainSpecificDecay(experience);
+        // No decay during grace period
+        if (age < specificConfig.decayStartDelay) {
+            return experience.confidence;
+        }
+        // Calculate decay based on half-life
+        const decayTime = age - specificConfig.decayStartDelay;
+        const halfLives = decayTime / specificConfig.halfLife;
+        const decayFactor = 0.5 ** halfLives;
+        // Apply decay but respect minimum
+        const decayedConfidence = experience.confidence * decayFactor;
+        return Math.max(specificConfig.minConfidence, decayedConfidence);
+    }
+    /**
+     * Get experiences that need reinforcement (low confidence due to decay)
+     */
+    getExperiencesNeedingReinforcement(experiences, threshold = 0.3) {
+        return experiences.filter((exp) => {
+            const decayed = this.getDecayedConfidence(exp);
+            return decayed < threshold && decayed > this.config.minConfidence;
+        });
+    }
+    /**
+     * Calculate reinforcement boost when an experience is validated
+     */
+    calculateReinforcementBoost(experience, validationStrength = 1.0) {
+        const currentConfidence = this.getDecayedConfidence(experience);
+        const boost = (1 - currentConfidence) * validationStrength * 0.5;
+        return Math.min(1, currentConfidence + boost);
+    }
+    /**
+     * Adjust decay rate based on experience type and domain
+     */
+    getDomainSpecificDecay(experience) {
+        const config = { ...this.config };
+        // Facts and discoveries decay slower
+        if (experience.type === ExperienceType.DISCOVERY ||
+            experience.type === ExperienceType.LEARNING) {
+            config.halfLife *= 2; // Double the half-life
+        }
+        // Warnings and corrections decay slower (important to remember)
+        if (experience.type === ExperienceType.WARNING ||
+            experience.type === ExperienceType.CORRECTION) {
+            config.halfLife *= 1.5;
+            config.minConfidence = 0.2; // Higher minimum
+        }
+        // Domain-specific adjustments
+        switch (experience.domain) {
+            case "security":
+            case "safety":
+                config.halfLife *= 3; // Security lessons decay very slowly
+                config.minConfidence = 0.3;
+                break;
+            case "performance":
+                config.halfLife *= 0.5; // Performance insights may change quickly
+                break;
+            case "user_preference":
+                config.halfLife *= 0.7; // User preferences can change
+                break;
+        }
+        return config;
+    }
+    /**
+     * Get confidence trend for an experience over time
+     */
+    getConfidenceTrend(experience, points = 10) {
+        const trend = [];
+        const now = Date.now();
+        const totalTime = now - experience.createdAt;
+        const interval = totalTime / (points - 1);
+        const specificConfig = this.getDomainSpecificDecay(experience);
+        for (let i = 0; i < points; i++) {
+            const timestamp = experience.createdAt + interval * i;
+            const age = timestamp - experience.createdAt;
+            let confidence;
+            if (age < specificConfig.decayStartDelay) {
+                confidence = experience.confidence;
+            }
+            else {
+                const decayTime = age - specificConfig.decayStartDelay;
+                const halfLives = decayTime / specificConfig.halfLife;
+                const decayFactor = 0.5 ** halfLives;
+                confidence = Math.max(specificConfig.minConfidence, experience.confidence * decayFactor);
+            }
+            trend.push({ timestamp, confidence });
+        }
+        return trend;
+    }
+}

package/packages/typescript/src/features/advanced-capabilities/experience/utils/experienceRelationships.d.ts

@@ -0,0 +1,26 @@
+import type { Experience, JsonObject } from "../types";
+export interface ExperienceChain {
+    rootExperience: string;
+    chain: string[];
+    strength: number;
+    validated: boolean;
+}
+export interface ExperienceRelationship {
+    fromId: string;
+    toId: string;
+    type: "causes" | "contradicts" | "supports" | "supersedes" | "related";
+    strength: number;
+    metadata?: JsonObject;
+}
+export declare class ExperienceRelationshipManager {
+    private relationships;
+    addRelationship(relationship: ExperienceRelationship): void;
+    removeExperience(experienceId: string): void;
+    findRelationships(experienceId: string, type?: string): ExperienceRelationship[];
+    detectCausalChain(experiences: Experience[]): ExperienceChain[];
+    private isRelated;
+    private contentSimilarity;
+    findContradictions(experience: Experience, allExperiences: Experience[]): Experience[];
+    getExperienceImpact(experienceId: string, allExperiences: Experience[]): number;
+}
+//# sourceMappingURL=experienceRelationships.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/experience/utils/experienceRelationships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experienceRelationships.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/utils/experienceRelationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGvD,MAAM,WAAW,eAAe;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,UAAU,GAAG,YAAY,GAAG,SAAS,CAAC;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACtB;AAED,qBAAa,6BAA6B;IACzC,OAAO,CAAC,aAAa,CAAoD;IAEzE,eAAe,CAAC,YAAY,EAAE,sBAAsB,GAAG,IAAI;IAQ3D,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAiB5C,iBAAiB,CAChB,YAAY,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,MAAM,GACX,sBAAsB,EAAE;IAQ3B,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,eAAe,EAAE;IAmD/D,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,iBAAiB;IAWzB,kBAAkB,CACjB,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,UAAU,EAAE,GAC1B,UAAU,EAAE;IAyBf,mBAAmB,CAClB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,UAAU,EAAE,GAC1B,MAAM;CAmBT"}

package/packages/typescript/src/features/advanced-capabilities/experience/utils/experienceRelationships.js

@@ -0,0 +1,129 @@
+import { ExperienceType, OutcomeType } from "../types";
+export class ExperienceRelationshipManager {
+    relationships = new Map();
+    addRelationship(relationship) {
+        const { fromId } = relationship;
+        if (!this.relationships.has(fromId)) {
+            this.relationships.set(fromId, []);
+        }
+        this.relationships.get(fromId)?.push(relationship);
+    }
+    removeExperience(experienceId) {
+        this.relationships.delete(experienceId);
+        for (const [fromId, relationships] of this.relationships) {
+            const remaining = relationships.filter((relationship) => relationship.toId !== experienceId);
+            if (remaining.length === 0) {
+                this.relationships.delete(fromId);
+                continue;
+            }
+            if (remaining.length !== relationships.length) {
+                this.relationships.set(fromId, remaining);
+            }
+        }
+    }
+    findRelationships(experienceId, type) {
+        const rels = this.relationships.get(experienceId) || [];
+        if (type) {
+            return rels.filter((r) => r.type === type);
+        }
+        return rels;
+    }
+    detectCausalChain(experiences) {
+        const chains = [];
+        // Sort experiences by timestamp
+        const sorted = [...experiences].sort((a, b) => a.createdAt - b.createdAt);
+        // Look for sequences where validation follows hypothesis
+        for (let i = 0; i < sorted.length - 1; i++) {
+            const current = sorted[i];
+            if (!current) {
+                continue;
+            }
+            if (current.type === ExperienceType.HYPOTHESIS) {
+                const chain = [current.id];
+                let j = i + 1;
+                // Look for related experiences
+                while (j < sorted.length) {
+                    const next = sorted[j];
+                    if (!next) {
+                        j++;
+                        continue;
+                    }
+                    // Check if next experience validates or contradicts the hypothesis
+                    if (next.relatedExperiences?.includes(current.id) ||
+                        this.isRelated(current, next)) {
+                        chain.push(next.id);
+                        // If we found a validation, create a chain
+                        if (next.type === ExperienceType.VALIDATION) {
+                            chains.push({
+                                rootExperience: current.id,
+                                chain,
+                                strength: next.confidence,
+                                validated: next.outcome === OutcomeType.POSITIVE,
+                            });
+                            break;
+                        }
+                    }
+                    j++;
+                }
+            }
+        }
+        return chains;
+    }
+    isRelated(exp1, exp2) {
+        // Check domain match
+        if (exp1.domain === exp2.domain) {
+            // Check temporal proximity (within 5 minutes)
+            const timeDiff = Math.abs(exp2.createdAt - exp1.createdAt);
+            if (timeDiff < 5 * 60 * 1000) {
+                // Check content similarity
+                if (this.contentSimilarity(exp1, exp2) > 0.7) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    contentSimilarity(exp1, exp2) {
+        // Simple keyword overlap for now
+        const words1 = new Set(exp1.learning.toLowerCase().split(/\s+/));
+        const words2 = new Set(exp2.learning.toLowerCase().split(/\s+/));
+        const intersection = new Set([...words1].filter((x) => words2.has(x)));
+        const union = new Set([...words1, ...words2]);
+        return intersection.size / union.size;
+    }
+    findContradictions(experience, allExperiences) {
+        const contradictions = [];
+        for (const other of allExperiences) {
+            if (other.id === experience.id)
+                continue;
+            // Same action, different outcome
+            if (other.action === experience.action &&
+                other.outcome !== experience.outcome &&
+                other.domain === experience.domain) {
+                contradictions.push(other);
+            }
+            // Explicit contradiction relationship
+            const rels = this.findRelationships(experience.id, "contradicts");
+            if (rels.some((r) => r.toId === other.id)) {
+                contradictions.push(other);
+            }
+        }
+        return contradictions;
+    }
+    getExperienceImpact(experienceId, allExperiences) {
+        let impact = 0;
+        for (const exp of allExperiences) {
+            if (exp.relatedExperiences?.includes(experienceId)) {
+                impact += exp.importance;
+            }
+        }
+        // Add impact from relationships
+        const relationships = this.findRelationships(experienceId);
+        for (const rel of relationships) {
+            if (rel.type === "causes") {
+                impact += rel.strength;
+            }
+        }
+        return impact;
+    }
+}

package/packages/typescript/src/features/advanced-capabilities/form/actions/restore.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module actions/restore
+ * @description Action for restoring stashed form sessions
+ *
+ * The restore operation is unique among form intents because:
+ * 1. Timing Matters: The restored form context must be available BEFORE response generation
+ * 2. Preemption: FORM_RESTORE should preempt REPLY
+ * 3. Immediate Context: After restore, the provider gives the agent the restored form context
+ */
+import { type Action } from "../../../../types/index.ts";
+export declare const formRestoreAction: Action;
+export default formRestoreAction;
+//# sourceMappingURL=restore.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/form/actions/restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restore.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/form/actions/restore.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACN,KAAK,MAAM,EASX,MAAM,4BAA4B,CAAC;AAIpC,eAAO,MAAM,iBAAiB,EAAE,MAsK/B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/form/actions/restore.js

@@ -0,0 +1,152 @@
+/**
+ * @module actions/restore
+ * @description Action for restoring stashed form sessions
+ *
+ * The restore operation is unique among form intents because:
+ * 1. Timing Matters: The restored form context must be available BEFORE response generation
+ * 2. Preemption: FORM_RESTORE should preempt REPLY
+ * 3. Immediate Context: After restore, the provider gives the agent the restored form context
+ */
+import { logger, } from "../../../../types/index.js";
+import { quickIntentDetect } from "../intent.js";
+export const 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) {
+            logger.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 };
+            }
+            // Check for existing active session in this room
+            const existing = await formService.getActiveSession(entityId, roomId);
+            if (existing) {
+                const form = formService.getForm(existing.formId);
+                await callback?.({
+                    text: `You already have an active form: "${form?.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 };
+            }
+            // Restore the most recent stashed session
+            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 += `\n\nHere's what I have so far:\n`;
+                for (const field of context.filledFields) {
+                    responseText += `\u2022 ${field.label}: ${field.displayValue}\n`;
+                }
+            }
+            if (context.nextField) {
+                responseText += `\nLet's continue with ${context.nextField.label}.`;
+                if (context.nextField.askPrompt) {
+                    responseText += ` ${context.nextField.askPrompt}`;
+                }
+            }
+            else if (context.status === "ready") {
+                responseText += `\nEverything 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 };
+        }
+    },
+    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...",
+                },
+            },
+        ],
+    ],
+};
+export default formRestoreAction;