@elizaos/interop 2.0.0-alpha

package/dist/typescript/wasm-loader.js

@@ -0,0 +1,269 @@
+/**
+ * WASM Plugin Loader for elizaOS
+ *
+ * Loads Rust (or other) plugins compiled to WebAssembly and adapts them
+ * to the TypeScript Plugin interface.
+ */
+/**
+ * Text encoder/decoder for string passing
+ */
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * Load a WASM plugin and return an elizaOS Plugin interface
+ */
+export async function loadWasmPlugin(options) {
+    const { wasmPath, manifestPath } = options;
+    // Load the WASM module
+    const wasmInstance = await loadWasmModule(wasmPath, options.imports);
+    // Get the manifest from the WASM module or external file
+    let manifest;
+    if (manifestPath) {
+        manifest = await loadManifest(manifestPath);
+    }
+    else {
+        // Try to get manifest from WASM exports
+        const manifestJson = wasmInstance.exports.get_manifest();
+        manifest = JSON.parse(manifestJson);
+    }
+    // Create the plugin adapter
+    return createPluginFromWasm(manifest, wasmInstance);
+}
+/**
+ * Load a WASM module and instantiate it
+ */
+async function loadWasmModule(wasmPath, customImports) {
+    // Default imports for WASM
+    const defaultImports = {
+        env: {
+            // Console logging
+            console_log: (_ptr, _len) => {
+                // Will be resolved once we have memory
+            },
+            console_error: (_ptr, _len) => {
+                // Will be resolved once we have memory
+            },
+            // Abort handler
+            abort: (_msg, file, line, column) => {
+                throw new Error(`WASM abort at ${file}:${line}:${column}`);
+            },
+        },
+        wasi_snapshot_preview1: {
+            // Minimal WASI stubs for compatibility
+            proc_exit: (code) => {
+                throw new Error(`WASM exit with code ${code}`);
+            },
+            fd_write: () => 0,
+            fd_read: () => 0,
+            fd_close: () => 0,
+            fd_seek: () => 0,
+            environ_get: () => 0,
+            environ_sizes_get: () => 0,
+            clock_time_get: () => 0,
+            random_get: (_buf, _len) => {
+                // Fill with random bytes
+                return 0;
+            },
+        },
+    };
+    const imports = { ...defaultImports, ...customImports };
+    // Determine if we're in Node.js or browser
+    const isNode = typeof globalThis.process !== "undefined" &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node;
+    let wasmModule;
+    if (isNode) {
+        // Node.js: read file
+        const fs = await import("node:fs/promises");
+        const wasmBuffer = await fs.readFile(wasmPath);
+        wasmModule = await WebAssembly.compile(wasmBuffer);
+    }
+    else {
+        // Browser: fetch
+        const response = await fetch(wasmPath);
+        const wasmBuffer = await response.arrayBuffer();
+        wasmModule = await WebAssembly.compile(wasmBuffer);
+    }
+    let instance = await WebAssembly.instantiate(wasmModule, defaultImports);
+    instance = await WebAssembly.instantiate(wasmModule, imports);
+    // Set up console logging now that we have memory
+    const memory = instance.exports.memory;
+    if (imports.env) {
+        const env = imports.env;
+        env.console_log = (ptr, len) => {
+            const bytes = new Uint8Array(memory.buffer, ptr, len);
+            console.log(decoder.decode(bytes));
+        };
+        env.console_error = (ptr, len) => {
+            const bytes = new Uint8Array(memory.buffer, ptr, len);
+            console.error(decoder.decode(bytes));
+        };
+    }
+    return {
+        exports: instance.exports,
+        memory: { buffer: memory.buffer },
+    };
+}
+/**
+ * Load manifest from external JSON file
+ */
+async function loadManifest(manifestPath) {
+    const isNode = typeof globalThis.process !== "undefined" &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node;
+    if (isNode) {
+        const fs = await import("node:fs/promises");
+        const content = await fs.readFile(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    else {
+        const response = await fetch(manifestPath);
+        return response.json();
+    }
+}
+/**
+ * Helper to pass a string to WASM and get result
+ */
+function _callWasmWithString(instance, fn, ...strings) {
+    const { exports, memory } = instance;
+    const ptrs = [];
+    const lens = [];
+    // Allocate and write strings
+    for (const str of strings) {
+        const bytes = encoder.encode(str);
+        const ptr = exports.alloc(bytes.length);
+        const view = new Uint8Array(memory.buffer, ptr, bytes.length);
+        view.set(bytes);
+        ptrs.push(ptr);
+        lens.push(bytes.length);
+    }
+    // Call the function
+    const args = [];
+    for (let i = 0; i < strings.length; i++) {
+        args.push(ptrs[i], lens[i]);
+    }
+    const resultPtr = fn(...args);
+    // Read result (assuming null-terminated or length-prefixed)
+    // For now, assume it returns a pointer to a null-terminated string
+    let resultLen = 0;
+    const view = new Uint8Array(memory.buffer);
+    while (view[resultPtr + resultLen] !== 0 &&
+        resultPtr + resultLen < view.length) {
+        resultLen++;
+    }
+    const result = decoder.decode(new Uint8Array(memory.buffer, resultPtr, resultLen));
+    // Deallocate input strings
+    for (let i = 0; i < strings.length; i++) {
+        exports.dealloc(ptrs[i], lens[i]);
+    }
+    return result;
+}
+/**
+ * Create a Plugin from a WASM instance
+ */
+function createPluginFromWasm(manifest, instance) {
+    const { exports } = instance;
+    // Create action wrappers
+    const actions = (manifest.actions ?? []).map((actionDef) => ({
+        name: actionDef.name,
+        description: actionDef.description,
+        similes: actionDef.similes,
+        examples: actionDef.examples,
+        validate: async (_runtime, message, state) => {
+            const result = exports.validate_action(actionDef.name, JSON.stringify(message), JSON.stringify(state ?? null));
+            return typeof result === "boolean" ? result : result !== 0;
+        },
+        handler: async (_runtime, message, state, options, _callback) => {
+            const resultJson = exports.invoke_action(actionDef.name, JSON.stringify(message), JSON.stringify(state ?? null), JSON.stringify(options ?? {}));
+            const result = JSON.parse(resultJson);
+            return {
+                success: result.success,
+                text: result.text,
+                error: result.error ? new Error(result.error) : undefined,
+                data: result.data,
+                values: result.values,
+            };
+        },
+    }));
+    // Create provider wrappers
+    const providers = (manifest.providers ?? []).map((providerDef) => ({
+        name: providerDef.name,
+        description: providerDef.description,
+        dynamic: providerDef.dynamic,
+        position: providerDef.position,
+        private: providerDef.private,
+        get: async (_runtime, message, state) => {
+            const resultJson = exports.get_provider(providerDef.name, JSON.stringify(message), JSON.stringify(state));
+            const result = JSON.parse(resultJson);
+            return {
+                text: result.text,
+                values: result.values,
+                data: result.data,
+            };
+        },
+    }));
+    // Create evaluator wrappers
+    const evaluators = (manifest.evaluators ?? []).map((evalDef) => ({
+        name: evalDef.name,
+        description: evalDef.description,
+        alwaysRun: evalDef.alwaysRun,
+        similes: evalDef.similes,
+        examples: [],
+        validate: async (_runtime, message, state) => {
+            const result = exports.validate_evaluator(evalDef.name, JSON.stringify(message), JSON.stringify(state ?? null));
+            return typeof result === "boolean" ? result : result !== 0;
+        },
+        handler: async (_runtime, message, state) => {
+            const resultJson = exports.invoke_evaluator(evalDef.name, JSON.stringify(message), JSON.stringify(state ?? null));
+            if (!resultJson || resultJson === "null") {
+                return undefined;
+            }
+            const result = JSON.parse(resultJson);
+            return {
+                success: result.success,
+                text: result.text,
+                error: result.error ? new Error(result.error) : undefined,
+                data: result.data,
+                values: result.values,
+            };
+        },
+    }));
+    // Return the plugin
+    return {
+        name: manifest.name,
+        description: manifest.description,
+        config: manifest.config ?? {},
+        dependencies: manifest.dependencies,
+        actions,
+        providers,
+        evaluators,
+        // Routes would need special handling for WASM
+        routes: [],
+        // Services need special handling
+        services: [],
+        async init(config) {
+            exports.init(JSON.stringify(config));
+        },
+    };
+}
+/**
+ * Preload and validate a WASM plugin without fully loading it
+ */
+export async function validateWasmPlugin(wasmPath) {
+    try {
+        const instance = await loadWasmModule(wasmPath, {});
+        const manifestJson = instance.exports.get_manifest();
+        const manifest = JSON.parse(manifestJson);
+        // Basic validation
+        if (!manifest.name || !manifest.description) {
+            return { valid: false, error: "Missing required manifest fields" };
+        }
+        return { valid: true, manifest };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@elizaos/interop",
+  "version": "2.0.0-alpha",
+  "description": "Cross-language plugin interoperability for elizaOS",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "python",
+    "rust"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --pool=threads",
+    "test:watch": "vitest --pool=threads",
+    "test:python": "cd python && pytest tests/ -v -p no:anchorpy --asyncio-mode=auto || echo 'Python tests skipped'",
+    "lint": "bunx @biomejs/biome check --write --unsafe .",
+    "lint:check": "bunx @biomejs/biome check .",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@elizaos/core": "2.0.0-alpha"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  },
+  "author": "elizaOS",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "97cb016b794d01bc07a552427734d2e98a1d674a"
+}

package/python/__init__.py

@@ -0,0 +1,50 @@
+"""
+elizaOS Cross-Language Interop - Python
+
+This module provides utilities for loading plugins written in other languages
+(Rust, TypeScript) into the Python runtime.
+
+This is a standalone package that can be installed separately or used from
+within the main elizaos package.
+"""
+
+# Rust FFI loader
+from .rust_ffi import (
+    RustPluginFFI,
+    find_rust_plugin,
+    get_lib_extension,
+    get_lib_prefix,
+    load_rust_plugin,
+)
+
+# WASM loader (for Rust/TypeScript WASM plugins)
+from .wasm_loader import (
+    WasmPluginLoader,
+    load_wasm_plugin,
+    validate_wasm_plugin,
+)
+
+# TypeScript bridge (for TypeScript plugins via IPC)
+from .ts_bridge import (
+    TypeScriptPluginBridge,
+    load_typescript_plugin,
+    stop_typescript_plugin,
+)
+
+__all__ = [
+    # Rust FFI
+    "RustPluginFFI",
+    "load_rust_plugin",
+    "find_rust_plugin",
+    "get_lib_extension",
+    "get_lib_prefix",
+    # WASM Loader
+    "WasmPluginLoader",
+    "load_wasm_plugin",
+    "validate_wasm_plugin",
+    # TypeScript Bridge
+    "TypeScriptPluginBridge",
+    "load_typescript_plugin",
+    "stop_typescript_plugin",
+]
+