@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

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

@@ -0,0 +1,362 @@
+/**
+ * FactRefinementEvaluator
+ *
+ * Honcho-style dialectic refinement for the facts memory store. Runs on the
+ * same trigger as the summarization evaluator: when a fresh summary lands we
+ * compare every existing fact for the relevant entity against the summary
+ * and classify the implication:
+ *
+ *   - add         → new fact memory
+ *   - strengthen  → bump confidence and update lastReinforced
+ *   - decay       → drop confidence; delete when below FACT_DECAY_FLOOR
+ *   - merge       → write to fact_candidates for human review
+ *   - contradict  → write to fact_candidates for human review
+ *
+ * The schema-level `fact_candidates` table receives anything we cannot apply
+ * automatically. The Facts UI surfaces those as "I noticed conflicting info".
+ */
+import { v4 } from "uuid";
+import { logger } from "../../../logger.js";
+import { ModelType } from "../../../types/index.js";
+import { MemoryType } from "../../../types/memory.js";
+import { asUUID } from "../../../types/primitives.js";
+const STRENGTHEN_DELTA = 0.1;
+const DECAY_DELTA = 0.15;
+const FACT_DECAY_FLOOR = 0.2;
+const MAX_FACTS_REVIEWED = 50;
+const SUMMARY_MEMORY_TYPE = "session_summary";
+/**
+ * Mirrors the summarization evaluator's trigger condition. We call into the
+ * memory service if available to avoid duplicating the threshold math; if
+ * the service is unavailable we skip rather than guess.
+ */
+async function summarizationTriggered(runtime, message) {
+    if (!message.content?.text)
+        return false;
+    const memoryServiceUnknown = runtime.getService("memory");
+    if (!memoryServiceUnknown || typeof memoryServiceUnknown !== "object") {
+        return false;
+    }
+    const memoryService = memoryServiceUnknown;
+    if (typeof memoryService.getConfig !== "function" ||
+        typeof memoryService.getCurrentSessionSummary !== "function") {
+        return false;
+    }
+    const config = memoryService.getConfig();
+    const summary = await memoryService.getCurrentSessionSummary(message.roomId);
+    const recentMessages = await runtime.getMemories({
+        tableName: "messages",
+        roomId: message.roomId,
+        limit: 200,
+        unique: false,
+    });
+    const dialogueCount = recentMessages.length;
+    if (!summary) {
+        const threshold = config.shortTermSummarizationThreshold ?? 10;
+        return dialogueCount >= threshold;
+    }
+    const interval = config.shortTermSummarizationInterval ?? 5;
+    const newCount = dialogueCount - (summary.lastMessageOffset ?? 0);
+    return newCount >= interval;
+}
+function readFactMetadata(memory) {
+    const meta = memory.metadata;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta))
+        return {};
+    return meta;
+}
+function pickFactConfidence(memory) {
+    const meta = readFactMetadata(memory);
+    const value = meta.confidence;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    return 0.6;
+}
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+function asUuidOrNull(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return null;
+    return asUUID(value);
+}
+function buildRefinementPrompt(summaryText, facts) {
+    const factLines = facts
+        .map((fact, index) => {
+        const id = fact.id ?? `idx_${index}`;
+        const confidence = pickFactConfidence(fact);
+        const text = fact.content?.text ?? "";
+        return `[${id}] (conf=${confidence.toFixed(2)}) ${text}`;
+    })
+        .join("\n");
+    return `You are refining a knowledge base for an AI assistant.
+
+A new conversation summary has just been generated. For each existing fact
+about a specific person, decide what to do given the summary.
+
+Allowed actions:
+- "add"        – the summary establishes a new durable fact not yet in the
+                 list. Provide the new fact text. (No factId required.)
+- "strengthen" – the summary reinforces an existing fact. Provide its factId.
+- "decay"      – the summary makes the fact look less likely (no longer
+                 mentioned, contradicted obliquely). Provide its factId.
+- "contradict" – the summary explicitly contradicts an existing fact. Provide
+                 its factId and a one-line reason.
+- "merge"      – two facts overlap and could be consolidated. Provide its
+                 factId and the proposed merged text.
+
+Return ONLY a JSON array of objects: { "action", "factId?", "text?", "reason?" }.
+Empty array means no changes.
+
+Conversation summary:
+${summaryText}
+
+Existing facts:
+${factLines || "(no facts on file yet)"}
+`;
+}
+function parseRefinementResponse(raw) {
+    const match = raw.match(/\[[\s\S]*\]/);
+    if (!match)
+        return [];
+    const parsed = JSON.parse(match[0]);
+    if (!Array.isArray(parsed))
+        return [];
+    const proposals = [];
+    for (const entry of parsed) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const record = entry;
+        const action = record.action;
+        if (action !== "add" &&
+            action !== "strengthen" &&
+            action !== "decay" &&
+            action !== "merge" &&
+            action !== "contradict") {
+            continue;
+        }
+        proposals.push({
+            action,
+            factId: typeof record.factId === "string" ? record.factId : undefined,
+            text: typeof record.text === "string" ? record.text : undefined,
+            reason: typeof record.reason === "string" ? record.reason : undefined,
+        });
+    }
+    return proposals;
+}
+async function applyStrengthen(runtime, fact, evidenceMessageId) {
+    const meta = readFactMetadata(fact);
+    const nextConfidence = clamp01(pickFactConfidence(fact) + STRENGTHEN_DELTA);
+    const evidence = Array.isArray(meta.evidenceMessageIds)
+        ? [...meta.evidenceMessageIds]
+        : [];
+    if (evidenceMessageId && !evidence.includes(evidenceMessageId)) {
+        evidence.push(evidenceMessageId);
+    }
+    if (typeof runtime.updateMemory !== "function" ||
+        typeof fact.id !== "string") {
+        return;
+    }
+    await runtime.updateMemory({
+        id: fact.id,
+        metadata: {
+            ...meta,
+            type: MemoryType.CUSTOM,
+            confidence: nextConfidence,
+            lastReinforced: new Date().toISOString(),
+            evidenceMessageIds: evidence,
+        },
+    });
+}
+async function applyDecay(runtime, fact) {
+    const meta = readFactMetadata(fact);
+    const nextConfidence = clamp01(pickFactConfidence(fact) - DECAY_DELTA);
+    if (nextConfidence < FACT_DECAY_FLOOR) {
+        if (typeof runtime.deleteMemory === "function" &&
+            typeof fact.id === "string") {
+            await runtime.deleteMemory(fact.id);
+        }
+        return;
+    }
+    if (typeof runtime.updateMemory !== "function" ||
+        typeof fact.id !== "string") {
+        return;
+    }
+    await runtime.updateMemory({
+        id: fact.id,
+        metadata: {
+            ...meta,
+            type: MemoryType.CUSTOM,
+            confidence: nextConfidence,
+        },
+    });
+}
+async function applyAdd(runtime, message, text) {
+    const factId = asUUID(v4());
+    const evidenceIds = message.id ? [message.id] : [];
+    await runtime.createMemory({
+        id: factId,
+        entityId: message.entityId,
+        agentId: runtime.agentId,
+        roomId: message.roomId,
+        content: { text },
+        metadata: {
+            type: MemoryType.CUSTOM,
+            source: "fact_refinement",
+            confidence: 0.7,
+            lastReinforced: new Date().toISOString(),
+            evidenceMessageIds: evidenceIds,
+        },
+        createdAt: Date.now(),
+    }, "facts", true);
+}
+async function getRuntimeDb(runtime) {
+    const adapter = runtime
+        .adapter;
+    const db = adapter?.db;
+    if (!db || typeof db.execute !== "function")
+        return null;
+    return db;
+}
+function sqlQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function sqlJsonbLiteral(value) {
+    return `${sqlQuote(JSON.stringify(value ?? null))}::jsonb`;
+}
+async function recordFactCandidate(runtime, params) {
+    const db = await getRuntimeDb(runtime);
+    if (!db)
+        return;
+    const drizzle = (await import("drizzle-orm"));
+    const evidence = {
+        reason: params.reason,
+        evidenceMessageId: params.evidenceMessageId,
+    };
+    const sqlText = `INSERT INTO fact_candidates (
+			agent_id, entity_id, kind, existing_fact_id, proposed_text,
+			confidence, evidence, status
+		) VALUES (
+			${sqlQuote(runtime.agentId)},
+			${sqlQuote(params.entityId)},
+			${sqlQuote(params.kind)},
+			${params.existingFactId ? sqlQuote(params.existingFactId) : "NULL"},
+			${sqlQuote(params.proposedText)},
+			0.6,
+			${sqlJsonbLiteral(evidence)},
+			'pending'
+		)`;
+    await db.execute(drizzle.sql.raw(sqlText));
+}
+export const factRefinementEvaluator = {
+    name: "FACT_REFINEMENT",
+    description: "Honcho-style dialectic refinement: classify each existing fact against the latest summary and apply add/strengthen/decay automatically; queue contradict/merge for review.",
+    similes: ["FACT_DIALECTIC", "FACT_REFRESHER", "FACT_PRUNER"],
+    alwaysRun: false,
+    examples: [],
+    validate: async (runtime, message, _state) => {
+        return summarizationTriggered(runtime, message);
+    },
+    handler: async (runtime, message, _state) => {
+        const entityId = message.entityId;
+        if (!entityId)
+            return undefined;
+        const [existingFacts, summaryMemories] = await Promise.all([
+            runtime.getMemories({
+                tableName: "facts",
+                roomId: message.roomId,
+                entityId,
+                count: MAX_FACTS_REVIEWED,
+                unique: true,
+            }),
+            runtime.getMemories({
+                tableName: "memories",
+                roomId: message.roomId,
+                count: 5,
+                unique: false,
+            }),
+        ]);
+        const latestSummary = summaryMemories
+            .filter((memory) => {
+            const meta = memory.metadata;
+            if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+                return false;
+            }
+            const record = meta;
+            return (record.type === SUMMARY_MEMORY_TYPE ||
+                record.source === "session_summary");
+        })
+            .sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0))[0];
+        const summaryText = latestSummary?.content?.text?.trim() ??
+            message.content?.text?.trim() ??
+            "";
+        if (!summaryText) {
+            return undefined;
+        }
+        const prompt = buildRefinementPrompt(summaryText, existingFacts);
+        const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+            maxTokens: 600,
+            temperature: 0,
+        });
+        const proposals = parseRefinementResponse(response);
+        if (proposals.length === 0) {
+            logger.debug("[FactRefinementEvaluator] No refinements produced for room " +
+                message.roomId);
+            return undefined;
+        }
+        const factById = new Map();
+        for (const fact of existingFacts) {
+            if (fact.id)
+                factById.set(fact.id, fact);
+        }
+        let applied = 0;
+        let queued = 0;
+        for (const proposal of proposals) {
+            if (proposal.action === "add" && proposal.text) {
+                await applyAdd(runtime, message, proposal.text);
+                applied += 1;
+                continue;
+            }
+            if (!proposal.factId)
+                continue;
+            const fact = factById.get(proposal.factId);
+            if (!fact)
+                continue;
+            if (proposal.action === "strengthen") {
+                await applyStrengthen(runtime, fact, asUuidOrNull(message.id));
+                applied += 1;
+                continue;
+            }
+            if (proposal.action === "decay") {
+                await applyDecay(runtime, fact);
+                applied += 1;
+                continue;
+            }
+            if (proposal.action === "contradict" || proposal.action === "merge") {
+                await recordFactCandidate(runtime, {
+                    entityId,
+                    kind: proposal.action,
+                    existingFactId: asUuidOrNull(fact.id) ?? undefined,
+                    proposedText: proposal.text ?? fact.content?.text ?? "",
+                    reason: proposal.reason,
+                    evidenceMessageId: asUuidOrNull(message.id) ?? undefined,
+                });
+                queued += 1;
+            }
+        }
+        logger.info(`[FactRefinementEvaluator] Applied ${applied}, queued ${queued} for room ${message.roomId}`);
+        return {
+            success: true,
+            values: { applied, queued },
+            data: { applied, queued },
+            text: `Refined ${applied} facts; queued ${queued} for review.`,
+        };
+    },
+};

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

@@ -3,6 +3,9 @@
  *
  * Evaluators for memory and relationship management.
  */
+export { factRefinementEvaluator } from "./factRefinement.ts";
 export { reflectionEvaluator } from "./reflection.ts";
 export { relationshipExtractionEvaluator } from "./relationshipExtraction.ts";
+export { skillExtractionEvaluator } from "./skillExtraction.ts";
+export { skillRefinementEvaluator } from "./skillRefinement.ts";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -3,5 +3,8 @@
  *
  * Evaluators for memory and relationship management.
  */
+export { factRefinementEvaluator } from "./factRefinement.js";
 export { reflectionEvaluator } from "./reflection.js";
 export { relationshipExtractionEvaluator } from "./relationshipExtraction.js";
+export { skillExtractionEvaluator } from "./skillExtraction.js";
+export { skillRefinementEvaluator } from "./skillRefinement.js";

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

@@ -1,5 +1,5 @@
 import { v4 } from "uuid";
-import { z } from "zod";
+import z from "zod";
 import { getEntityDetails } from "../../../entities.js";
 import { requireEvaluatorSpec } from "../../../generated/spec-helpers.js";
 import { reflectionEvaluatorTemplate } from "../../../prompts.js";

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

@@ -1 +1 @@
-{"version":3,"file":"relationshipExtraction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAIX,SAAS,EAKT,MAAM,yBAAyB,CAAC;AA0CjC,eAAO,MAAM,+BAA+B,EAAE,SAyG7C,CAAC"}
+{"version":3,"file":"relationshipExtraction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAIX,SAAS,EAKT,MAAM,yBAAyB,CAAC;AA0CjC,eAAO,MAAM,+BAA+B,EAAE,SA+G7C,CAAC"}

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

@@ -33,6 +33,7 @@ export const relationshipExtractionEvaluator = {
         const identities = extractPlatformIdentities(message.content.text);
         if (identities.length > 0) {
             await storePlatformIdentities(runtime, message.entityId, identities);
+            await upsertEntityIdentities(relationshipsService, message.entityId, identities, message.id ? [message.id] : []);
         }
         // Check for disputes or corrections
         const disputeInfo = detectDispute(message.content.text, recentMessages);
@@ -608,6 +609,26 @@ async function handleAdminUpdates(runtime, message, _recentMessages) {
         }
     }
 }
+/**
+ * Persist extracted platform identities to the strengthened
+ * `entity_identities` table via RelationshipsService. Each call records
+ * provenance (the message id that triggered the observation) so we can rebuild
+ * an evidence trail later.
+ */
+async function upsertEntityIdentities(relationshipsService, entityId, identities, evidenceMessageIds) {
+    if (typeof relationshipsService.upsertIdentity !== "function") {
+        return;
+    }
+    for (const identity of identities) {
+        await relationshipsService.upsertIdentity(entityId, {
+            platform: identity.platform,
+            handle: identity.handle,
+            verified: identity.verified,
+            confidence: identity.confidence,
+            source: "relationship_extraction",
+        }, evidenceMessageIds);
+    }
+}
 async function findEntityByName(runtime, name, roomId) {
     const entities = await runtime.getEntitiesForRoom(roomId);
     for (const entity of entities) {

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

@@ -0,0 +1,25 @@
+/**
+ * Skill extraction evaluator.
+ *
+ * Watches successful trajectories and asks an LLM whether the agent just
+ * executed a generalizable procedure that should be lifted into a reusable
+ * SKILL.md. Drafted skills are staged under
+ * `~/.milady/skills/curated/proposed/<name>/SKILL.md` with provenance set to
+ * `agent-generated`. Proposed skills are NEVER auto-loaded into the runtime —
+ * the user reviews them via the Settings → Learned Skills panel and either
+ * promotes, edits, or discards.
+ *
+ * Triggers when:
+ *   - the just-completed trajectory has status "completed"
+ *   - the trajectory has at least 5 steps
+ *   - no curated skill was used (avoids self-reinforcing extraction loops)
+ *
+ * The validator is intentionally cheap; the handler bears the LLM cost.
+ */
+import type { Evaluator } from "../../../types/index.ts";
+export declare const skillExtractionEvaluator: Evaluator;
+/**
+ * Internal helper exposed for tests — counts proposed skill directories.
+ */
+export declare function _countProposedSkills(): number;
+//# sourceMappingURL=skillExtraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skillExtraction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/skillExtraction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAGX,SAAS,EAGT,MAAM,yBAAyB,CAAC;AA4QjC,eAAO,MAAM,wBAAwB,EAAE,SA2KtC,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAM7C"}