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

package/packages/typescript/src/features/advanced-capabilities/evaluators/skillRefinement.js

@@ -0,0 +1,541 @@
+/**
+ * Skill refinement evaluator.
+ *
+ * When a curated skill participated in a trajectory that failed (or was
+ * retried), ask an LLM to propose a diff against the current SKILL.md.
+ *
+ * Refinement budget: the first three auto-refinements are applied directly to
+ * the active skill (provenance.refinedCount increments, derivedFromTrajectory
+ * + createdAt update). After that, additional proposed refinements are staged
+ * under `~/.milady/skills/curated/proposed/<name>/SKILL.md` so the user can
+ * review them via the Settings → Learned Skills panel.
+ *
+ * Triggers when:
+ *   - a curated skill was used in the latest trajectory (TrajectoryStep.usedSkills,
+ *     falling back to trajectory.metadata.usedSkills)
+ *   - the trajectory's status is "failed" OR a retry signal is present in
+ *     metadata.retryCount/metadata.retryDetected
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "../../../logger.js";
+import { ModelType } from "../../../types/index.js";
+import { resolveStateDir } from "../../../utils/state-dir.js";
+const EVAL_NAME = "SKILL_REFINEMENT";
+const EVAL_DESCRIPTION = "Refines curated SKILL.md files when they participated in a failing or retried trajectory.";
+const MAX_AUTO_REFINEMENTS = 3;
+const REFINEMENT_PROMPT = `You are improving a SKILL.md file because the agent recently failed or
+retried while using it.
+
+Output a single fenced JSON block:
+\`\`\`json
+{
+  "refine": true,
+  "newBody": "<full replacement markdown body, no frontmatter>",
+  "reason": "<short reason>"
+}
+\`\`\`
+
+If no refinement is warranted, return:
+\`\`\`json
+{ "refine": false, "reason": "<short reason>" }
+\`\`\`
+
+Rules:
+- newBody MUST be the complete replacement markdown body (the frontmatter is
+  preserved separately and updated automatically).
+- newBody MUST NOT contain a YAML frontmatter block (---).
+- Keep the skill focused: tighten steps, add guardrails for the failure mode,
+  remove ambiguity. Do not invent capabilities the agent does not have.`;
+function getActiveSkillsDir() {
+    return join(resolveStateDir(), "skills", "curated", "active");
+}
+function getProposedSkillsDir() {
+    return join(resolveStateDir(), "skills", "curated", "proposed");
+}
+function parseRefinementResponse(raw) {
+    const fenceMatch = raw.match(/```json\s*([\s\S]*?)\s*```/i);
+    const jsonText = fenceMatch ? fenceMatch[1] : raw.trim();
+    if (!jsonText)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const obj = parsed;
+    const draft = { refine: obj.refine === true };
+    if (typeof obj.reason === "string")
+        draft.reason = obj.reason;
+    if (typeof obj.newBody === "string")
+        draft.newBody = obj.newBody;
+    return draft;
+}
+function parseSkillFile(content) {
+    const normalized = content.replace(/\r\n/g, "\n");
+    if (!normalized.startsWith("---")) {
+        return null;
+    }
+    const endIdx = normalized.indexOf("\n---", 3);
+    if (endIdx === -1) {
+        return null;
+    }
+    const yaml = normalized.slice(4, endIdx);
+    const body = normalized.slice(endIdx + 4).replace(/^\n+/, "");
+    const frontmatter = parseYamlBlock(yaml);
+    return { frontmatter, body };
+}
+/**
+ * Tiny YAML reader for the constrained subset we emit (flat keys, plus a
+ * single-level `provenance:` map). Anything richer falls through unchanged.
+ */
+function parseYamlBlock(yaml) {
+    const result = {};
+    const lines = yaml.split("\n");
+    let i = 0;
+    while (i < lines.length) {
+        const rawLine = lines[i];
+        i += 1;
+        if (rawLine === undefined)
+            continue;
+        const line = rawLine.replace(/\s+$/, "");
+        if (!line || line.startsWith("#"))
+            continue;
+        if (/^\s/.test(line))
+            continue;
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        if (value === "") {
+            const child = {};
+            while (i < lines.length) {
+                const nextRaw = lines[i];
+                if (nextRaw === undefined)
+                    break;
+                if (!/^\s+\S/.test(nextRaw))
+                    break;
+                const sub = nextRaw.trim();
+                const subColon = sub.indexOf(":");
+                if (subColon === -1) {
+                    i += 1;
+                    continue;
+                }
+                const subKey = sub.slice(0, subColon).trim();
+                const subValRaw = sub.slice(subColon + 1).trim();
+                child[subKey] = coerceScalar(subValRaw);
+                i += 1;
+            }
+            result[key] = child;
+            continue;
+        }
+        result[key] = coerceScalar(value);
+    }
+    return result;
+}
+function coerceScalar(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value === "null" || value === "~")
+        return null;
+    if (/^-?\d+$/.test(value))
+        return Number(value);
+    if (/^-?\d+\.\d+$/.test(value))
+        return Number(value);
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function escapeYamlScalar(value) {
+    if (/[:#"'\n]/.test(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+function serializeSkillFile(frontmatter, body) {
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            lines.push(`${key}:`);
+            for (const [subKey, subValue] of Object.entries(value)) {
+                lines.push(`  ${subKey}: ${formatYamlValue(subValue)}`);
+            }
+        }
+        else {
+            lines.push(`${key}: ${formatYamlValue(value)}`);
+        }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trimEnd());
+    lines.push("");
+    return lines.join("\n");
+}
+function formatYamlValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "boolean" || typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "string")
+        return escapeYamlScalar(value);
+    return JSON.stringify(value);
+}
+function trajectoryUsedSkills(trajectory) {
+    const collected = new Set();
+    for (const step of trajectory.steps ?? []) {
+        const used = step.usedSkills;
+        if (Array.isArray(used)) {
+            for (const name of used) {
+                if (typeof name === "string" && name.trim()) {
+                    collected.add(name.trim());
+                }
+            }
+        }
+    }
+    const metaUsed = trajectory.metadata?.usedSkills;
+    if (Array.isArray(metaUsed)) {
+        for (const name of metaUsed) {
+            if (typeof name === "string" && name.trim()) {
+                collected.add(name.trim());
+            }
+        }
+    }
+    return [...collected];
+}
+function trajectoryFailedOrRetried(trajectory) {
+    const status = trajectory.metrics?.finalStatus ?? "";
+    if (status === "failed")
+        return true;
+    const meta = trajectory.metadata ?? {};
+    const retryCount = meta.retryCount;
+    if (typeof retryCount === "number" && retryCount > 0)
+        return true;
+    if (meta.retryDetected === true)
+        return true;
+    return false;
+}
+function pickMostRecent(items) {
+    if (items.length === 0)
+        return undefined;
+    const sorted = [...items].sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0));
+    return sorted[0];
+}
+function getTrajectoryService(runtime) {
+    const svc = runtime.getService("trajectories");
+    if (!svc)
+        return null;
+    const shape = svc;
+    if (typeof shape.listTrajectories !== "function" ||
+        typeof shape.getTrajectoryDetail !== "function") {
+        return null;
+    }
+    return shape;
+}
+function locateActiveSkill(name) {
+    const skillPath = join(getActiveSkillsDir(), name, "SKILL.md");
+    if (existsSync(skillPath))
+        return skillPath;
+    return null;
+}
+function formatTrajectoryForPrompt(trajectory) {
+    const lines = [];
+    lines.push(`Trajectory: ${trajectory.trajectoryId}`);
+    lines.push(`Final status: ${trajectory.metrics?.finalStatus ?? "unknown"}`);
+    let stepIdx = 0;
+    for (const step of trajectory.steps ?? []) {
+        stepIdx += 1;
+        lines.push(`--- Step ${stepIdx} ---`);
+        for (const call of step.llmCalls ?? []) {
+            lines.push(`[${call.purpose ?? call.actionType ?? "step"}]`);
+            if (call.userPrompt) {
+                lines.push(`USER: ${call.userPrompt.slice(0, 600)}`);
+            }
+            if (call.response) {
+                lines.push(`AGENT: ${call.response.slice(0, 600)}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export const skillRefinementEvaluator = {
+    name: EVAL_NAME,
+    description: EVAL_DESCRIPTION,
+    similes: [],
+    alwaysRun: false,
+    examples: [],
+    validate: async (runtime) => {
+        const service = getTrajectoryService(runtime);
+        if (!service?.listTrajectories || !service.getTrajectoryDetail)
+            return false;
+        const list = await service.listTrajectories({ limit: 5 });
+        const latest = pickMostRecent(list.trajectories ?? []);
+        if (!latest)
+            return false;
+        const detail = await service.getTrajectoryDetail(latest.id);
+        if (!detail)
+            return false;
+        if (!trajectoryFailedOrRetried(detail))
+            return false;
+        return trajectoryUsedSkills(detail).length > 0;
+    },
+    handler: async (runtime) => {
+        const service = getTrajectoryService(runtime);
+        if (!service?.listTrajectories || !service.getTrajectoryDetail)
+            return undefined;
+        const list = await service.listTrajectories({ limit: 5 });
+        const latest = pickMostRecent(list.trajectories ?? []);
+        if (!latest)
+            return undefined;
+        const trajectory = await service.getTrajectoryDetail(latest.id);
+        if (!trajectory)
+            return undefined;
+        if (!trajectoryFailedOrRetried(trajectory))
+            return undefined;
+        const skills = trajectoryUsedSkills(trajectory);
+        if (skills.length === 0)
+            return undefined;
+        const refinedNames = [];
+        const proposedNames = [];
+        const trajectoryDigest = formatTrajectoryForPrompt(trajectory);
+        for (const skillName of skills) {
+            const activePath = locateActiveSkill(skillName);
+            if (!activePath)
+                continue;
+            const currentText = readFileSync(activePath, "utf-8");
+            const parsed = parseSkillFile(currentText);
+            if (!parsed) {
+                logger.warn({
+                    src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                    agentId: runtime.agentId,
+                    skillName,
+                }, "Active skill file did not parse — skipping refinement");
+                continue;
+            }
+            const prompt = `${REFINEMENT_PROMPT}\n\nCurrent SKILL.md body:\n${parsed.body}\n\nFailing trajectory:\n${trajectoryDigest}`;
+            const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+            if (!response || typeof response !== "string")
+                continue;
+            const draft = parseRefinementResponse(response);
+            if (!draft?.refine || !draft.newBody)
+                continue;
+            if (draft.newBody.includes("---")) {
+                logger.warn({
+                    src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                    agentId: runtime.agentId,
+                    skillName,
+                }, "Refinement body contained frontmatter delimiter — skipping");
+                continue;
+            }
+            const provenanceRaw = parsed.frontmatter.provenance;
+            const provenance = provenanceRaw &&
+                typeof provenanceRaw === "object" &&
+                !Array.isArray(provenanceRaw)
+                ? { ...provenanceRaw }
+                : {
+                    source: "human",
+                    createdAt: new Date().toISOString(),
+                    refinedCount: 0,
+                };
+            const currentRefinedCount = typeof provenance.refinedCount === "number"
+                ? provenance.refinedCount
+                : 0;
+            const nowIso = new Date().toISOString();
+            if (currentRefinedCount < MAX_AUTO_REFINEMENTS) {
+                provenance.source = "agent-refined";
+                provenance.derivedFromTrajectory = trajectory.trajectoryId;
+                provenance.createdAt = nowIso;
+                provenance.refinedCount = currentRefinedCount + 1;
+                const newFrontmatter = {
+                    ...parsed.frontmatter,
+                    provenance,
+                };
+                writeFileSync(activePath, serializeSkillFile(newFrontmatter, draft.newBody), "utf-8");
+                refinedNames.push(skillName);
+                logger.info({
+                    src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                    agentId: runtime.agentId,
+                    skillName,
+                    refinedCount: provenance.refinedCount,
+                }, "Auto-applied skill refinement");
+            }
+            else {
+                // Gradient mode — the LLM-diff auto-budget is exhausted, so we
+                // switch to the native `prompt-evolution` optimizer. It pulls
+                // trajectories tagged with this skill and rewrites the SKILL.md
+                // body via the optimizer instead of by single-shot LLM diff.
+                //
+                // We dynamic-import the optimizer module so @elizaos/core does
+                // not gain a hard dependency on @elizaos/app-training; the
+                // import resolves only when the training package is installed
+                // (which is the case in this monorepo). When the import fails,
+                // we fall back to the previous "stage for human review"
+                // behaviour so the closed loop never silently drops a refinement.
+                const gradientResult = await tryGradientRefinement({
+                    runtime,
+                    trajectoryService: service,
+                    skillName,
+                    skillBody: parsed.body,
+                });
+                if (gradientResult) {
+                    const lineage = Array.isArray(provenance.optimizationLineage)
+                        ? [
+                            ...provenance.optimizationLineage,
+                        ]
+                        : [];
+                    lineage.push({
+                        optimizer: gradientResult.optimizer,
+                        score: gradientResult.score,
+                        datasetSize: gradientResult.datasetSize,
+                        generatedAt: nowIso,
+                    });
+                    provenance.source = "agent-refined";
+                    provenance.derivedFromTrajectory = trajectory.trajectoryId;
+                    provenance.createdAt = nowIso;
+                    provenance.optimizationLineage = lineage;
+                    const newFrontmatter = {
+                        ...parsed.frontmatter,
+                        provenance,
+                    };
+                    writeFileSync(activePath, serializeSkillFile(newFrontmatter, gradientResult.optimizedBody), "utf-8");
+                    refinedNames.push(skillName);
+                    logger.info({
+                        src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                        agentId: runtime.agentId,
+                        skillName,
+                        optimizer: gradientResult.optimizer,
+                        score: gradientResult.score,
+                        datasetSize: gradientResult.datasetSize,
+                    }, "Gradient-mode skill refinement applied via native optimizer");
+                    continue;
+                }
+                const proposedDir = join(getProposedSkillsDir(), skillName);
+                if (existsSync(proposedDir)) {
+                    logger.debug({
+                        src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                        agentId: runtime.agentId,
+                        skillName,
+                    }, "Refinement already proposed — skipping");
+                    continue;
+                }
+                mkdirSync(proposedDir, { recursive: true });
+                provenance.source = "agent-refined";
+                provenance.derivedFromTrajectory = trajectory.trajectoryId;
+                provenance.createdAt = nowIso;
+                const stagedFrontmatter = {
+                    ...parsed.frontmatter,
+                    provenance,
+                };
+                writeFileSync(join(proposedDir, "SKILL.md"), serializeSkillFile(stagedFrontmatter, draft.newBody), "utf-8");
+                proposedNames.push(skillName);
+                logger.info({
+                    src: "plugin:advanced-capabilities:evaluator:skill_refinement",
+                    agentId: runtime.agentId,
+                    skillName,
+                }, "Staged refinement for human review (auto-budget exhausted)");
+            }
+        }
+        if (refinedNames.length === 0 && proposedNames.length === 0) {
+            return undefined;
+        }
+        return {
+            success: true,
+            text: `Refined ${refinedNames.length} skills, staged ${proposedNames.length} for review`,
+            values: {
+                skillRefinementApplied: refinedNames.length,
+                skillRefinementStaged: proposedNames.length,
+            },
+            data: {
+                refinedSkills: refinedNames,
+                proposedSkills: proposedNames,
+                trajectoryId: trajectory.trajectoryId,
+            },
+        };
+    },
+};
+/**
+ * Run the native `prompt-evolution` optimizer over the trajectories that
+ * referenced this skill. Returns null when the optimizer module is not
+ * installed, when there are too few trajectories to optimize against, or
+ * when the optimization did not improve over the baseline.
+ *
+ * Uses dynamic import so @elizaos/core does not gain a hard dependency on
+ * @elizaos/app-training.
+ */
+async function tryGradientRefinement(input) {
+    const optimizers = await loadOptimizerModule();
+    if (!optimizers)
+        return null;
+    const trajectories = await collectSkillTrajectories(input.trajectoryService, input.skillName);
+    if (trajectories.length < 3)
+        return null;
+    const dataset = trajectories.flatMap((trajectory) => extractOptimizationExamples(trajectory));
+    if (dataset.length === 0)
+        return null;
+    const adapter = optimizers.createRuntimeAdapter((args) => input.runtime.useModel(ModelType.TEXT_LARGE, args));
+    const scorer = optimizers.createPromptScorer(adapter);
+    const result = await optimizers.runPromptEvolution({
+        baselinePrompt: input.skillBody,
+        dataset,
+        scorer,
+        llm: adapter,
+        options: { population: 4, generations: 2, mutationRate: 0.5 },
+    });
+    if (result.score <= result.baseline)
+        return null;
+    return {
+        optimizedBody: result.optimizedPrompt,
+        score: result.score,
+        optimizer: "prompt-evolution",
+        datasetSize: dataset.length,
+    };
+}
+async function loadOptimizerModule() {
+    const dynamicImport = new Function("name", "return import(name);");
+    const mod = (await dynamicImport("@elizaos/app-training/optimizers").catch(() => null));
+    if (mod &&
+        typeof mod.createRuntimeAdapter === "function" &&
+        typeof mod.createPromptScorer === "function" &&
+        typeof mod.runPromptEvolution === "function") {
+        return mod;
+    }
+    return null;
+}
+async function collectSkillTrajectories(service, skillName) {
+    if (!service.listTrajectories || !service.getTrajectoryDetail)
+        return [];
+    const list = await service.listTrajectories({ limit: 50 });
+    const collected = [];
+    for (const item of list.trajectories ?? []) {
+        const detail = await service.getTrajectoryDetail(item.id);
+        if (!detail)
+            continue;
+        const used = trajectoryUsedSkills(detail);
+        if (used.includes(skillName))
+            collected.push(detail);
+    }
+    return collected;
+}
+function extractOptimizationExamples(trajectory) {
+    const out = [];
+    for (const step of trajectory.steps ?? []) {
+        for (const call of step.llmCalls ?? []) {
+            if (!call.userPrompt || !call.response)
+                continue;
+            out.push({
+                input: { user: call.userPrompt, system: call.systemPrompt },
+                expectedOutput: call.response,
+            });
+        }
+    }
+    return out;
+}

package/packages/typescript/src/features/advanced-capabilities/evaluators/task-completion.d.ts

@@ -0,0 +1,12 @@
+import type { UUID } from "../../../types/index.ts";
+export interface TaskCompletionAssessment {
+    assessed: boolean;
+    completed: boolean;
+    reason: string;
+    source: "reflection";
+    evaluatedAt: number;
+    messageId?: UUID;
+}
+export declare function getTaskCompletionCacheKey(messageId: UUID): string;
+export declare function formatTaskCompletionStatus(assessment: TaskCompletionAssessment | null | undefined): string;
+//# sourceMappingURL=task-completion.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/evaluators/task-completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-completion.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/task-completion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD,MAAM,WAAW,wBAAwB;IACxC,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAEjE;AAED,wBAAgB,0BAA0B,CACzC,UAAU,EAAE,wBAAwB,GAAG,IAAI,GAAG,SAAS,GACrD,MAAM,CAWR"}

package/packages/typescript/src/features/advanced-capabilities/evaluators/task-completion.js

@@ -0,0 +1,14 @@
+export function getTaskCompletionCacheKey(messageId) {
+    return `reflection-task-completion:${messageId}`;
+}
+export function formatTaskCompletionStatus(assessment) {
+    if (!assessment) {
+        return "No task completion reflection is available.";
+    }
+    return [
+        "# Reflection Task Completion",
+        `assessed: ${assessment.assessed ? "true" : "false"}`,
+        `task_completed: ${assessment.completed ? "true" : "false"}`,
+        `task_completion_reason: ${assessment.reason}`,
+    ].join("\n");
+}

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

@@ -0,0 +1,3 @@
+import type { Action } from "../../../../types/components.ts";
+export declare const recordExperienceAction: Action;
+//# sourceMappingURL=record-experience.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record-experience.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/actions/record-experience.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,MAAM,EAKN,MAAM,iCAAiC,CAAC;AAUzC,eAAO,MAAM,sBAAsB,EAAE,MAoGpC,CAAC"}

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

@@ -0,0 +1,71 @@
+import { logger } from "../../../../logger.js";
+import { requireActionSpec } from "../generated/specs/spec-helpers";
+import { ExperienceType, OutcomeType } from "../types.js";
+const spec = requireActionSpec("RECORD_EXPERIENCE");
+export const recordExperienceAction = {
+    name: spec.name,
+    similes: spec.similes ? [...spec.similes] : [],
+    description: spec.description,
+    examples: (spec.examples ?? []),
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avKeywords = ["record", "experience"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+        const __avRegex = /\b(?:record|experience)\b/i;
+        const __avRegexOk = Boolean(__avText.match(__avRegex));
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (_runtime, message) => {
+            const text = message.content.text?.toLowerCase();
+            return text?.includes("remember") || text?.includes("record") || false;
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message));
+        }
+        catch {
+            return false;
+        }
+    },
+    async handler(runtime, message, state, _options, _callback) {
+        void _options;
+        void _callback;
+        logger.info(`[RecordExperienceAction] Recording experience for message ${message.id}`);
+        const experienceService = runtime.getService("EXPERIENCE");
+        if (!experienceService) {
+            logger.error("[RecordExperienceAction] Experience service is unavailable");
+            return {
+                success: false,
+                text: "Experience service is unavailable.",
+            };
+        }
+        const learningText = typeof message.content.text === "string" ? message.content.text : "";
+        const recordedExperience = await experienceService.recordExperience({
+            type: ExperienceType.LEARNING,
+            outcome: OutcomeType.NEUTRAL,
+            context: state?.text ?? "",
+            action: learningText,
+            result: "Recorded from explicit remember/record request.",
+            learning: learningText,
+        });
+        logger.info(`[RecordExperienceAction] Experience recorded successfully (${recordedExperience.id})`);
+        return {
+            success: true,
+            text: "Experience recorded.",
+            data: {
+                experienceId: recordedExperience.id,
+            },
+        };
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Evaluator } from "../../../../types/components.ts";
+export declare const experienceEvaluator: Evaluator;
+//# sourceMappingURL=experienceEvaluator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"experienceEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/evaluators/experienceEvaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEX,SAAS,EAGT,MAAM,iCAAiC,CAAC;AAkBzC,eAAO,MAAM,mBAAmB,EAAE,SA8OjC,CAAC"}