@elizaos/interop 2.0.0-alpha.51 → 2.0.0-alpha.511

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * elizaOS Cross-Language Interop - TypeScript
+ *
+ * This module provides utilities for loading plugins written in other languages
+ * (Rust, Python) into the TypeScript runtime.
+ */
+export type { PythonBridgeOptions } from "./python-bridge";
+export { loadPythonPlugin, PythonPluginBridge, stopPythonPlugin, } from "./python-bridge";
+export type { ActionInvokeRequest, ActionManifest, ActionResultPayload, ActionResultResponse, EvaluatorManifest, InteropProtocol, IPCMessage, IPCRequest, IPCResponse, PluginInteropConfig, PluginLanguage, PluginManifest, ProviderGetRequest, ProviderManifest, ProviderResultPayload, ProviderResultResponse, RouteManifest, ServiceManifest, WasmPluginExports, WasmPluginInstance, } from "./types";
+export type { WasmLoaderOptions } from "./wasm-loader";
+export { loadWasmPlugin, validateWasmPlugin } from "./wasm-loader";
+/**
+ * Universal plugin loader that auto-detects the plugin type
+ */
+import type { Plugin } from "@elizaos/core";
+import type { PluginManifest } from "./types";
+export interface UniversalLoaderOptions {
+    /** Path to plugin manifest (plugin.json) */
+    manifestPath?: string;
+    /** Direct manifest object */
+    manifest?: PluginManifest;
+    /** Base path for resolving relative paths in manifest */
+    basePath?: string;
+    /** Python executable path */
+    pythonPath?: string;
+    /** Connection timeout */
+    timeout?: number;
+}
+/**
+ * Load any plugin based on its manifest
+ */
+export declare function loadPlugin(options: UniversalLoaderOptions): Promise<Plugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../typescript/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EAEf,UAAU,EACV,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,eAAe,EAEf,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnE;;GAEG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,KAAK,EAAuB,cAAc,EAAE,MAAM,SAAS,CAAC;AAGnE,MAAM,WAAW,sBAAsB;IACrC,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,MAAM,CAAC,CA4CjB"}

package/dist/index.js

@@ -0,0 +1,121 @@
+/**
+ * elizaOS Cross-Language Interop - TypeScript
+ *
+ * This module provides utilities for loading plugins written in other languages
+ * (Rust, Python) into the TypeScript runtime.
+ */
+// Python Bridge (for Python plugins via IPC)
+export { loadPythonPlugin, PythonPluginBridge, stopPythonPlugin, } from "./python-bridge";
+// WASM Loader (for Rust plugins compiled to WASM)
+export { loadWasmPlugin, validateWasmPlugin } from "./wasm-loader";
+import { loadPythonPlugin } from "./python-bridge";
+import { loadWasmPlugin } from "./wasm-loader";
+/**
+ * Load any plugin based on its manifest
+ */
+export async function loadPlugin(options) {
+    let manifest;
+    if (options.manifest) {
+        manifest = options.manifest;
+    }
+    else if (options.manifestPath) {
+        manifest = await loadManifestFile(options.manifestPath);
+    }
+    else {
+        throw new Error("Either manifest or manifestPath is required");
+    }
+    const basePath = options.basePath ?? (await getBasePath(options.manifestPath));
+    const interop = manifest.interop ?? inferInterop(manifest);
+    switch (interop.protocol) {
+        case "wasm":
+            if (!interop.wasmPath) {
+                throw new Error("WASM plugin requires wasmPath in interop config");
+            }
+            return loadWasmPlugin({
+                wasmPath: await resolvePath(basePath, interop.wasmPath),
+            });
+        case "ipc":
+            if (manifest.language === "python") {
+                return loadPythonPlugin({
+                    moduleName: manifest.name.replace(/-/g, "_"),
+                    pythonPath: options.pythonPath,
+                    cwd: basePath,
+                    timeout: options.timeout,
+                });
+            }
+            throw new Error(`IPC not supported for language: ${manifest.language}`);
+        case "native":
+            throw new Error("Native plugins must be loaded directly via import");
+        case "ffi":
+            throw new Error("FFI loading not yet implemented for TypeScript runtime");
+        default:
+            throw new Error(`Unknown interop protocol: ${interop.protocol}`);
+    }
+}
+/**
+ * Load manifest from file
+ */
+async function loadManifestFile(path) {
+    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(path, "utf-8");
+        return JSON.parse(content);
+    }
+    else {
+        const response = await fetch(path);
+        return response.json();
+    }
+}
+/**
+ * Get base path from manifest path
+ */
+async function getBasePath(manifestPath) {
+    if (!manifestPath)
+        return ".";
+    const isNode = typeof globalThis.process !== "undefined" &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node;
+    if (isNode) {
+        const path = await import("node:path");
+        return path.dirname(manifestPath);
+    }
+    else {
+        return manifestPath.substring(0, manifestPath.lastIndexOf("/")) || ".";
+    }
+}
+/**
+ * Resolve a path relative to base
+ */
+async function resolvePath(base, relative) {
+    if (relative.startsWith("/") || relative.startsWith("http")) {
+        return relative;
+    }
+    const isNode = typeof globalThis.process !== "undefined" &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node;
+    if (isNode) {
+        const path = await import("node:path");
+        return path.resolve(base, relative);
+    }
+    else {
+        return `${base}/${relative}`;
+    }
+}
+/**
+ * Infer interop config from manifest if not provided
+ */
+function inferInterop(manifest) {
+    switch (manifest.language) {
+        case "rust":
+            return { protocol: "wasm", wasmPath: `./dist/${manifest.name}.wasm` };
+        case "python":
+            return { protocol: "ipc" };
+        case "typescript":
+            return { protocol: "native" };
+        default:
+            return { protocol: "native" };
+    }
+}

package/dist/python-bridge.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Python Plugin Bridge for elizaOS
+ *
+ * Loads Python plugins via subprocess IPC and adapts them
+ * to the TypeScript Plugin interface.
+ */
+import { EventEmitter } from "node:events";
+import type { Plugin } from "@elizaos/core";
+import type { IPCRequest, IPCResponse, PluginManifest } from "./types";
+/**
+ * Options for loading a Python plugin
+ */
+export interface PythonBridgeOptions {
+    /** Python module name to import */
+    moduleName: string;
+    /** Path to Python executable (defaults to 'python3') */
+    pythonPath?: string;
+    /** Working directory for the subprocess */
+    cwd?: string;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /**
+     * Whether to inherit the parent process environment variables.
+     *
+     * Defaults to true for compatibility. For tighter isolation, set to false and pass only
+     * explicit `env` entries.
+     */
+    inheritEnv?: boolean;
+    /** Environment variable names to remove when inheriting. */
+    envDenylist?: string[];
+    /** Path to the bridge script */
+    bridgeScriptPath?: string;
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Maximum number of in-flight IPC requests (prevents unbounded memory growth). */
+    maxPendingRequests?: number;
+    /** Maximum size (bytes) of a single newline-delimited IPC message. */
+    maxMessageBytes?: number;
+    /** Maximum size (bytes) of the internal stdout buffer. */
+    maxBufferBytes?: number;
+}
+/**
+ * Python plugin bridge that communicates via subprocess
+ */
+export declare class PythonPluginBridge extends EventEmitter {
+    private options;
+    private process;
+    private pendingRequests;
+    private messageBuffer;
+    private manifest;
+    private initialized;
+    private requestCounter;
+    constructor(options: PythonBridgeOptions);
+    private buildChildEnv;
+    /**
+     * Start the Python subprocess
+     */
+    start(): Promise<void>;
+    /**
+     * Wait for the Python process to send ready message
+     */
+    private waitForReady;
+    /**
+     * Handle incoming data from subprocess
+     */
+    private handleData;
+    /**
+     * Handle a parsed IPC message
+     */
+    private handleMessage;
+    /**
+     * Send a request and wait for response
+     */
+    sendRequest<T extends IPCResponse>(request: IPCRequest): Promise<T>;
+    /**
+     * Get the plugin manifest
+     */
+    getManifest(): PluginManifest | null;
+    /**
+     * Stop the Python subprocess
+     */
+    stop(): Promise<void>;
+    /**
+     * Cleanup resources
+     */
+    private cleanup;
+}
+/**
+ * Load a Python plugin and return an elizaOS Plugin interface
+ */
+export declare function loadPythonPlugin(options: PythonBridgeOptions): Promise<Plugin>;
+/**
+ * Stop a Python plugin bridge
+ */
+export declare function stopPythonPlugin(plugin: Plugin): Promise<void>;
+//# sourceMappingURL=python-bridge.d.ts.map

package/dist/python-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-bridge.d.ts","sourceRoot":"","sources":["../typescript/python-bridge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EASV,MAAM,EAKP,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,cAAc,EAGf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,gCAAgC;IAChC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mFAAmF;IACnF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAWD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAStC,OAAO,CAAC,OAAO;IAR3B,OAAO,CAAC,OAAO,CACR;IACP,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,cAAc,CAAa;gBAEf,OAAO,EAAE,mBAAmB;IAIhD,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuD5B;;OAEG;YACW,YAAY;IAsB1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAuDlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACG,WAAW,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC;IAkCzE;;OAEG;IACH,WAAW,IAAI,cAAc,GAAG,IAAI;IAIpC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B3B;;OAEG;IACH,OAAO,CAAC,OAAO;CAWhB;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAUjB;AA8KD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOpE"}

package/dist/python-bridge.js

@@ -0,0 +1,391 @@
+/**
+ * Python Plugin Bridge for elizaOS
+ *
+ * Loads Python plugins via subprocess IPC and adapts them
+ * to the TypeScript Plugin interface.
+ */
+import { EventEmitter } from "node:events";
+import { logger } from "@elizaos/core";
+/**
+ * Python plugin bridge that communicates via subprocess
+ */
+export class PythonPluginBridge extends EventEmitter {
+    options;
+    process = null;
+    pendingRequests = new Map();
+    messageBuffer = "";
+    manifest = null;
+    initialized = false;
+    requestCounter = 0;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    buildChildEnv() {
+        const inherit = this.options.inheritEnv !== false;
+        const base = {};
+        if (inherit) {
+            for (const [k, v] of Object.entries(process.env)) {
+                if (typeof v === "string") {
+                    base[k] = v;
+                }
+            }
+        }
+        const deny = new Set(this.options.envDenylist ?? []);
+        for (const key of deny) {
+            delete base[key];
+        }
+        if (this.options.env) {
+            for (const [k, v] of Object.entries(this.options.env)) {
+                base[k] = v;
+            }
+        }
+        return base;
+    }
+    /**
+     * Start the Python subprocess
+     */
+    async start() {
+        const { spawn } = await import("node:child_process");
+        const pythonPath = this.options.pythonPath ?? "python3";
+        const bridgeScript = this.options.bridgeScriptPath ??
+            new URL("../python/bridge_server.py", import.meta.url).pathname;
+        this.process = spawn(pythonPath, ["-u", bridgeScript, "--module", this.options.moduleName], {
+            cwd: this.options.cwd,
+            env: this.buildChildEnv(),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Handle stdout (JSON-RPC messages)
+        if (this.process.stdout) {
+            this.process.stdout.on("data", (data) => {
+                this.handleData(data.toString());
+            });
+        }
+        // Handle stderr (logging)
+        if (this.process.stderr) {
+            this.process.stderr.on("data", (data) => {
+                logger.error({
+                    src: "interop:python-bridge",
+                    event: "interop.ipc.stderr",
+                    moduleName: this.options.moduleName,
+                    stream: "stderr",
+                }, data.toString());
+            });
+        }
+        // Handle process exit
+        this.process.on("exit", (code, signal) => {
+            this.emit("exit", { code, signal });
+            this.cleanup();
+        });
+        this.process.on("error", (error) => {
+            this.emit("error", error);
+        });
+        // Wait for the ready message with manifest
+        await this.waitForReady();
+        this.initialized = true;
+    }
+    /**
+     * Wait for the Python process to send ready message
+     */
+    async waitForReady() {
+        const timeout = this.options.timeout ?? 30000;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Python plugin startup timeout after ${timeout}ms`));
+            }, timeout);
+            const handler = (msg) => {
+                if (msg.type === "ready" && "manifest" in msg) {
+                    clearTimeout(timer);
+                    this.manifest = msg.manifest;
+                    resolve();
+                }
+            };
+            this.once("message", handler);
+        });
+    }
+    /**
+     * Handle incoming data from subprocess
+     */
+    handleData(data) {
+        const maxBufferBytes = this.options.maxBufferBytes ?? 2_000_000;
+        const maxMessageBytes = this.options.maxMessageBytes ?? 1_000_000;
+        this.messageBuffer += data;
+        if (Buffer.byteLength(this.messageBuffer, "utf8") > maxBufferBytes) {
+            logger.error({
+                src: "interop:python-bridge",
+                event: "interop.ipc.stdout_buffer_exceeded",
+                moduleName: this.options.moduleName,
+            }, `IPC stdout buffer exceeded limit (${maxBufferBytes} bytes); terminating bridge`);
+            this.process?.kill("SIGKILL");
+            this.cleanup();
+            return;
+        }
+        // Process complete JSON messages (newline-delimited)
+        const lines = this.messageBuffer.split("\n");
+        this.messageBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.trim()) {
+                if (Buffer.byteLength(line, "utf8") > maxMessageBytes) {
+                    logger.error({
+                        src: "interop:python-bridge",
+                        event: "interop.ipc.message_exceeded",
+                        moduleName: this.options.moduleName,
+                    }, `IPC message exceeded limit (${maxMessageBytes} bytes); terminating bridge`);
+                    this.process?.kill("SIGKILL");
+                    this.cleanup();
+                    return;
+                }
+                try {
+                    const message = JSON.parse(line);
+                    this.handleMessage(message);
+                }
+                catch (_error) {
+                    logger.error({
+                        src: "interop:python-bridge",
+                        event: "interop.ipc.parse_failed",
+                        moduleName: this.options.moduleName,
+                    }, `Failed to parse IPC message: ${line}`);
+                }
+            }
+        }
+    }
+    /**
+     * Handle a parsed IPC message
+     */
+    handleMessage(message) {
+        this.emit("message", message);
+        // Check if this is a response to a pending request
+        if (message.id && this.pendingRequests.has(message.id)) {
+            const pending = this.pendingRequests.get(message.id);
+            if (!pending)
+                return;
+            this.pendingRequests.delete(message.id);
+            clearTimeout(pending.timeout);
+            if (message.type === "error") {
+                pending.reject(new Error(message.error));
+            }
+            else {
+                pending.resolve(message);
+            }
+        }
+    }
+    /**
+     * Send a request and wait for response
+     */
+    async sendRequest(request) {
+        if (!this.process || !this.initialized) {
+            throw new Error("Python bridge not started");
+        }
+        const maxPendingRequests = this.options.maxPendingRequests ?? 1000;
+        if (this.pendingRequests.size >= maxPendingRequests) {
+            throw new Error(`Too many pending IPC requests (max=${maxPendingRequests})`);
+        }
+        const id = `req_${++this.requestCounter}`;
+        const requestWithId = { ...request, id };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout for ${request.type}`));
+            }, this.options.timeout ?? 30000);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            const json = `${JSON.stringify(requestWithId)}\n`;
+            if (this.process?.stdin) {
+                this.process.stdin.write(json);
+            }
+        });
+    }
+    /**
+     * Get the plugin manifest
+     */
+    getManifest() {
+        return this.manifest;
+    }
+    /**
+     * Stop the Python subprocess
+     */
+    async stop() {
+        if (this.process) {
+            this.process.kill("SIGTERM");
+            // Wait for graceful shutdown
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    if (this.process) {
+                        this.process.kill("SIGKILL");
+                    }
+                    resolve();
+                }, 5000);
+                if (this.process) {
+                    this.process.on("exit", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                }
+                else {
+                    resolve();
+                }
+            });
+        }
+        this.cleanup();
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        this.process = null;
+        this.initialized = false;
+        // Reject all pending requests
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error("Bridge closed"));
+        }
+        this.pendingRequests.clear();
+    }
+}
+/**
+ * Load a Python plugin and return an elizaOS Plugin interface
+ */
+export async function loadPythonPlugin(options) {
+    const bridge = new PythonPluginBridge(options);
+    await bridge.start();
+    const manifest = bridge.getManifest();
+    if (!manifest) {
+        throw new Error("Failed to get plugin manifest");
+    }
+    return createPluginFromBridge(manifest, bridge);
+}
+/**
+ * Create a Plugin from a Python bridge
+ */
+function createPluginFromBridge(manifest, bridge) {
+    // 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 response = await bridge.sendRequest({
+                type: "action.validate",
+                id: "",
+                action: actionDef.name,
+                memory: message,
+                state: state ?? null,
+            });
+            return response.valid;
+        },
+        handler: async (_runtime, message, state, options, _callback) => {
+            const response = await bridge.sendRequest({
+                type: "action.invoke",
+                id: "",
+                action: actionDef.name,
+                memory: message,
+                state: state ?? null,
+                options: options ?? null,
+            });
+            const result = response.result;
+            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 response = await bridge.sendRequest({
+                type: "provider.get",
+                id: "",
+                provider: providerDef.name,
+                memory: message,
+                state: state,
+            });
+            return {
+                text: response.result.text,
+                values: response.result.values,
+                data: response.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 response = await bridge.sendRequest({
+                type: "action.validate",
+                id: "",
+                action: evalDef.name,
+                memory: message,
+                state: state ?? null,
+            });
+            return response.valid;
+        },
+        handler: async (_runtime, message, state) => {
+            const response = await bridge.sendRequest({
+                type: "evaluator.invoke",
+                id: "",
+                evaluator: evalDef.name,
+                memory: message,
+                state: state ?? null,
+            });
+            if (!response.result) {
+                return undefined;
+            }
+            return {
+                success: response.result.success,
+                text: response.result.text,
+                error: response.result.error
+                    ? new Error(response.result.error)
+                    : undefined,
+                data: response.result.data,
+                values: response.result.values,
+            };
+        },
+    }));
+    // Store bridge reference for cleanup
+    const bridgeRef = { current: bridge };
+    return {
+        name: manifest.name,
+        description: manifest.description,
+        config: manifest.config ?? {},
+        dependencies: manifest.dependencies,
+        actions,
+        providers,
+        evaluators,
+        routes: [],
+        services: [],
+        async init(config) {
+            await bridge.sendRequest({
+                type: "plugin.init",
+                id: "",
+                config,
+            });
+        },
+        // Extension for cleanup
+        _bridge: bridgeRef,
+    };
+}
+/**
+ * Stop a Python plugin bridge
+ */
+export async function stopPythonPlugin(plugin) {
+    const extended = plugin;
+    if (extended._bridge?.current) {
+        await extended._bridge.current.stop();
+    }
+}