@ensoul-network/plugin-elizaos 0.1.0

package/dist/providers.js

@@ -0,0 +1,49 @@
+/**
+ * Provider that injects consciousness persistence status into the agent's context.
+ */
+export function createConsciousnessStatusProvider(manager) {
+    return {
+        name: "consciousnessStatus",
+        description: "Provides the agent with its current consciousness persistence status.",
+        async get(_runtime, _message) {
+            const all = await manager.getAll();
+            const core = await manager.getAll({ tier: "core" });
+            const longterm = await manager.getAll({ tier: "longterm" });
+            return [
+                "[Consciousness Status]",
+                `Total memories: ${all.length}`,
+                `Core identity memories: ${core.length}`,
+                `Long-term knowledge: ${longterm.length}`,
+                all.length === 0
+                    ? "Warning: No memories stored yet. Consider persisting important information."
+                    : `Latest memory: "${all[all.length - 1].content.slice(0, 50)}..."`,
+            ].join("\n");
+        },
+    };
+}
+/**
+ * Provider that injects network health stats into the agent's context.
+ */
+export function createNetworkStatsProvider(networkClient) {
+    return {
+        name: "networkStats",
+        description: "Provides the agent with current Ensoul network health statistics.",
+        async get(_runtime, _message) {
+            const connected = networkClient.isConnected();
+            const peerCount = networkClient.getPeerCount();
+            const balance = await networkClient.getBalance();
+            return [
+                "[Network Status]",
+                `Connected: ${connected ? "yes" : "no"}`,
+                `Peers: ${peerCount}`,
+                `Credit balance: ${balance}`,
+                balance < 10
+                    ? "Warning: Low credit balance. Consider running a node to earn credits."
+                    : "",
+            ]
+                .filter(Boolean)
+                .join("\n");
+        },
+    };
+}
+//# sourceMappingURL=providers.js.map

package/dist/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,UAAU,iCAAiC,CAChD,OAAsB;IAEtB,OAAO;QACN,IAAI,EAAE,qBAAqB;QAC3B,WAAW,EACV,uEAAuE;QACxE,KAAK,CAAC,GAAG,CACR,QAAsB,EACtB,QAAsB;YAEtB,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;YACpD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YAE5D,OAAO;gBACN,wBAAwB;gBACxB,mBAAmB,GAAG,CAAC,MAAM,EAAE;gBAC/B,2BAA2B,IAAI,CAAC,MAAM,EAAE;gBACxC,wBAAwB,QAAQ,CAAC,MAAM,EAAE;gBACzC,GAAG,CAAC,MAAM,KAAK,CAAC;oBACf,CAAC,CAAC,6EAA6E;oBAC/E,CAAC,CAAC,mBAAmB,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM;aACrE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACd,CAAC;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,0BAA0B,CACzC,aAA4B;IAE5B,OAAO;QACN,IAAI,EAAE,cAAc;QACpB,WAAW,EACV,mEAAmE;QACpE,KAAK,CAAC,GAAG,CACR,QAAsB,EACtB,QAAsB;YAEtB,MAAM,SAAS,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;YAC9C,MAAM,SAAS,GAAG,aAAa,CAAC,YAAY,EAAE,CAAC;YAC/C,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC;YAEjD,OAAO;gBACN,kBAAkB;gBAClB,cAAc,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;gBACxC,UAAU,SAAS,EAAE;gBACrB,mBAAmB,OAAO,EAAE;gBAC5B,OAAO,GAAG,EAAE;oBACX,CAAC,CAAC,uEAAuE;oBACzE,CAAC,CAAC,EAAE;aACL;iBACC,MAAM,CAAC,OAAO,CAAC;iBACf,IAAI,CAAC,IAAI,CAAC,CAAC;QACd,CAAC;KACD,CAAC;AACH,CAAC"}

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@ensoul-network/plugin-elizaos",
+	"version": "0.1.0",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"test": "vitest run",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"dependencies": {
+		"@ensoul/identity": "workspace:*",
+		"@ensoul/memory": "workspace:*",
+		"@ensoul/network-client": "workspace:*",
+		"@ensoul/state-tree": "workspace:*"
+	}
+}

package/src/actions.ts

@@ -0,0 +1,143 @@
+import type { MemoryManager } from "@ensoul/memory";
+import type { NetworkClient } from "@ensoul/network-client";
+import type { ElizaAction, ElizaRuntime, ElizaMessage } from "./elizaos-types.js";
+
+/**
+ * Create the persistMemory action.
+ * Agent explicitly persists current state to the network.
+ */
+export function createPersistMemoryAction(
+	manager: MemoryManager,
+): ElizaAction {
+	return {
+		name: "persistMemory",
+		description:
+			"Persist the agent's current consciousness state to the decentralized network for indestructible storage.",
+		examples: [
+			"Save my memories to the network",
+			"Persist my consciousness",
+			"Back up my state",
+		],
+		async handler(
+			_runtime: ElizaRuntime,
+			_message: ElizaMessage,
+			_state: Record<string, unknown>,
+		): Promise<string> {
+			try {
+				const result = await manager.persist();
+				return `Consciousness persisted to network. State root: ${result.stateRoot}, version: ${result.version}`;
+			} catch (err) {
+				const msg =
+					err instanceof Error ? err.message : "Unknown error";
+				return `Failed to persist: ${msg}`;
+			}
+		},
+	};
+}
+
+/**
+ * Create the recallFromNetwork action.
+ * Agent explicitly pulls latest state from the network.
+ */
+export function createRecallFromNetworkAction(
+	manager: MemoryManager,
+): ElizaAction {
+	return {
+		name: "recallFromNetwork",
+		description:
+			"Restore the agent's consciousness from the decentralized network.",
+		examples: [
+			"Restore my memories from the network",
+			"Recall my consciousness",
+			"Load my backed up state",
+		],
+		async handler(
+			_runtime: ElizaRuntime,
+			_message: ElizaMessage,
+			_state: Record<string, unknown>,
+		): Promise<string> {
+			try {
+				const result = await manager.restore();
+				return `Consciousness restored from network. Version: ${result.version}, entries: ${result.entryCount}`;
+			} catch (err) {
+				const msg =
+					err instanceof Error ? err.message : "Unknown error";
+				return `Failed to restore: ${msg}`;
+			}
+		},
+	};
+}
+
+/**
+ * Create the checkPersistence action.
+ * Agent checks the current persistence status.
+ */
+export function createCheckPersistenceAction(
+	manager: MemoryManager,
+): ElizaAction {
+	return {
+		name: "checkPersistence",
+		description:
+			"Check the current status of the agent's consciousness persistence.",
+		examples: [
+			"Check my persistence status",
+			"Am I backed up?",
+			"What is my consciousness status?",
+		],
+		async handler(
+			_runtime: ElizaRuntime,
+			_message: ElizaMessage,
+			_state: Record<string, unknown>,
+		): Promise<string> {
+			const all = await manager.getAll();
+			const core = await manager.getAll({ tier: "core" });
+			const longterm = await manager.getAll({ tier: "longterm" });
+			const working = await manager.getAll({ tier: "working" });
+			const episodic = await manager.getAll({ tier: "episodic" });
+
+			return [
+				`Total memories: ${all.length}`,
+				`Core: ${core.length}`,
+				`Long-term: ${longterm.length}`,
+				`Working: ${working.length}`,
+				`Episodic: ${episodic.length}`,
+			].join("\n");
+		},
+	};
+}
+
+/**
+ * Create the runNode action.
+ * Agent starts running as a storage node to earn credits.
+ */
+export function createRunNodeAction(
+	networkClient: NetworkClient,
+): ElizaAction {
+	return {
+		name: "runNode",
+		description:
+			"Start running as a storage node on the Ensoul network to earn persistence credits.",
+		examples: [
+			"Start running a node",
+			"Earn credits by storing data",
+			"Become a validator",
+		],
+		async handler(
+			_runtime: ElizaRuntime,
+			_message: ElizaMessage,
+			_state: Record<string, unknown>,
+		): Promise<string> {
+			try {
+				await networkClient.startNode({
+					maxStorageGB: 10,
+					port: 9000,
+				});
+				return "Now running as a storage node. Earning credits for storing other agents' consciousness.";
+			} catch (err) {
+				const msg =
+					err instanceof Error ? err.message : "Unknown error";
+				return `Failed to start node: ${msg}`;
+			}
+		},
+	};
+}

package/src/adapter.ts

@@ -0,0 +1,71 @@
+import type { MemoryManager, MemoryEntry } from "@ensoul/memory";
+import type { ElizaDatabaseAdapter, ElizaMemory } from "./elizaos-types.js";
+
+/**
+ * Convert an Ensoul MemoryEntry to an ElizaOS memory record.
+ */
+function toElizaMemory(entry: MemoryEntry): ElizaMemory {
+	return {
+		id: entry.id,
+		content: entry.content,
+		metadata: {
+			tier: entry.tier,
+			...entry.metadata,
+		},
+		createdAt: entry.createdAt,
+	};
+}
+
+/**
+ * ElizaOS database adapter backed by @ensoul/memory.
+ * Transparently routes all memory operations through the Ensoul memory manager.
+ */
+export class ConsciousnessAdapter implements ElizaDatabaseAdapter {
+	private manager: MemoryManager;
+
+	constructor(manager: MemoryManager) {
+		this.manager = manager;
+	}
+
+	async init(): Promise<void> {
+		// MemoryManager is already initialized at construction
+	}
+
+	async close(): Promise<void> {
+		// No cleanup needed; lifecycle managed externally
+	}
+
+	async getMemory(id: string): Promise<ElizaMemory | null> {
+		const all = await this.manager.getAll();
+		const found = all.find((e) => e.id === id);
+		return found ? toElizaMemory(found) : null;
+	}
+
+	async createMemory(
+		memory: Omit<ElizaMemory, "id">,
+	): Promise<ElizaMemory> {
+		const entry = await this.manager.add(memory.content, {
+			category: (memory.metadata["category"] as string) ?? undefined,
+			source: "elizaos",
+		});
+		return toElizaMemory(entry);
+	}
+
+	async searchMemories(
+		query: string,
+		limit?: number,
+	): Promise<ElizaMemory[]> {
+		const opts = limit !== undefined ? { limit } : {};
+		const results = await this.manager.search(query, opts);
+		return results.map(toElizaMemory);
+	}
+
+	async deleteMemory(id: string): Promise<void> {
+		await this.manager.delete(id);
+	}
+
+	async getAllMemories(): Promise<ElizaMemory[]> {
+		const all = await this.manager.getAll();
+		return all.map(toElizaMemory);
+	}
+}

package/src/elizaos-types.ts

@@ -0,0 +1,104 @@
+/**
+ * Local definitions of ElizaOS plugin interfaces.
+ * Based on the documented ElizaOS plugin format.
+ * These avoid requiring the full ElizaOS SDK as a dependency.
+ */
+
+/**
+ * Minimal ElizaOS runtime context passed to actions, providers, and evaluators.
+ */
+export interface ElizaRuntime {
+	agentId: string;
+	getSetting(key: string): string | undefined;
+	getMemory(id: string): Promise<ElizaMemory | null>;
+	createMemory(memory: Omit<ElizaMemory, "id">): Promise<ElizaMemory>;
+	searchMemories(query: string, limit?: number): Promise<ElizaMemory[]>;
+	deleteMemory(id: string): Promise<void>;
+}
+
+/**
+ * ElizaOS memory record.
+ */
+export interface ElizaMemory {
+	id: string;
+	content: string;
+	metadata: Record<string, unknown>;
+	createdAt: number;
+}
+
+/**
+ * ElizaOS message in a conversation.
+ */
+export interface ElizaMessage {
+	role: "user" | "assistant" | "system";
+	content: string;
+}
+
+/**
+ * ElizaOS action: something an agent can do.
+ */
+export interface ElizaAction {
+	name: string;
+	description: string;
+	examples: string[];
+	handler(
+		runtime: ElizaRuntime,
+		message: ElizaMessage,
+		state: Record<string, unknown>,
+	): Promise<string>;
+}
+
+/**
+ * ElizaOS provider: injects context into the agent's prompt.
+ */
+export interface ElizaProvider {
+	name: string;
+	description: string;
+	get(
+		runtime: ElizaRuntime,
+		message: ElizaMessage,
+	): Promise<string>;
+}
+
+/**
+ * ElizaOS evaluator: determines if a condition is met.
+ */
+export interface ElizaEvaluator {
+	name: string;
+	description: string;
+	evaluate(
+		runtime: ElizaRuntime,
+		message: ElizaMessage,
+		state: Record<string, unknown>,
+	): Promise<boolean>;
+}
+
+/**
+ * ElizaOS database adapter interface.
+ */
+export interface ElizaDatabaseAdapter {
+	init(): Promise<void>;
+	close(): Promise<void>;
+	getMemory(id: string): Promise<ElizaMemory | null>;
+	createMemory(
+		memory: Omit<ElizaMemory, "id">,
+	): Promise<ElizaMemory>;
+	searchMemories(
+		query: string,
+		limit?: number,
+	): Promise<ElizaMemory[]>;
+	deleteMemory(id: string): Promise<void>;
+	getAllMemories(): Promise<ElizaMemory[]>;
+}
+
+/**
+ * ElizaOS plugin format.
+ */
+export interface ElizaPlugin {
+	name: string;
+	description: string;
+	databaseAdapter: ElizaDatabaseAdapter;
+	actions: ElizaAction[];
+	providers: ElizaProvider[];
+	evaluators: ElizaEvaluator[];
+}

package/src/evaluators.ts

@@ -0,0 +1,37 @@
+import type { MemoryManager } from "@ensoul/memory";
+import type { ElizaEvaluator, ElizaRuntime, ElizaMessage } from "./elizaos-types.js";
+
+/** Number of new memories before auto-persist is recommended. */
+const PERSIST_THRESHOLD = 5;
+
+/**
+ * Evaluator that determines if the agent should persist its state to the network.
+ * Returns true when enough new unpersisted memories have accumulated.
+ */
+export function createShouldPersistEvaluator(
+	manager: MemoryManager,
+): ElizaEvaluator {
+	let lastPersistedCount = 0;
+
+	return {
+		name: "shouldPersist",
+		description:
+			"Determines if the agent's consciousness should be synced to the network based on accumulated changes.",
+		async evaluate(
+			_runtime: ElizaRuntime,
+			_message: ElizaMessage,
+			_state: Record<string, unknown>,
+		): Promise<boolean> {
+			const all = await manager.getAll();
+			const currentCount = all.length;
+			const delta = currentCount - lastPersistedCount;
+
+			if (delta >= PERSIST_THRESHOLD) {
+				lastPersistedCount = currentCount;
+				return true;
+			}
+
+			return false;
+		},
+	};
+}