@elizaos/interop 2.0.0-alpha.2 → 2.0.0-alpha.26

package/dist/typescript/wasm-loader.js

@@ -1,269 +0,0 @@
-/**
- * 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),
-        };
-    }
-}