@elizaos/plugin-rlm 2.0.0-alpha.3

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+import { Plugin } from '@elizaos/core';
+
+/** Types for the RLM (Recursive Language Model) plugin. */
+type RLMBackend = "openai" | "anthropic" | "gemini" | "groq" | "openrouter";
+type RLMEnvironment = "local" | "docker" | "modal" | "prime";
+interface RLMConfig {
+    backend: RLMBackend;
+    backendKwargs: Record<string, string>;
+    environment: RLMEnvironment;
+    maxIterations: number;
+    maxDepth: number;
+    verbose: boolean;
+    pythonPath: string;
+    maxRetries?: number;
+    retryBaseDelay?: number;
+    retryMaxDelay?: number;
+}
+interface RLMMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+interface RLMMetadata {
+    stub: boolean;
+    iterations?: number;
+    depth?: number;
+    error?: string;
+}
+interface RLMResult {
+    text: string;
+    metadata: RLMMetadata;
+}
+interface RLMInferOptions {
+    /** Model identifier for this request */
+    model?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Sampling temperature */
+    temperature?: number;
+    /** Top-p sampling parameter */
+    topP?: number;
+    /** Stop sequences */
+    stopSequences?: string[];
+    /** User identifier for tracking */
+    user?: string;
+    /** Enable streaming (not yet supported by RLM) */
+    stream?: boolean;
+    /** Override max iterations for this request */
+    maxIterations?: number;
+    /** Override max recursion depth for this request */
+    maxDepth?: number;
+    /** Override root model for this request */
+    rootModel?: string;
+    /** Override subcall model for this request */
+    subcallModel?: string;
+    /** Enable trajectory logging for this request */
+    logTrajectories?: boolean;
+    /** Enable cost tracking for this request */
+    trackCosts?: boolean;
+}
+interface RLMStatusResponse {
+    available: boolean;
+    backend: string;
+    environment: string;
+    maxIterations: number;
+    maxDepth: number;
+}
+interface GenerateTextParams {
+    prompt?: string;
+    system?: string;
+    messages?: RLMMessage[];
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+    user?: string;
+    stream?: boolean;
+}
+declare const DEFAULT_CONFIG: RLMConfig;
+interface RLMMetrics {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    stubResponses: number;
+    totalRetries: number;
+    averageLatencyMs: number;
+    p95LatencyMs: number;
+    lastRequestTimestamp: number;
+    lastErrorTimestamp?: number;
+    lastError?: string;
+}
+type MetricsCallback = (metrics: RLMMetrics) => void;
+declare const ENV_VARS: {
+    readonly BACKEND: "ELIZA_RLM_BACKEND";
+    readonly ENVIRONMENT: "ELIZA_RLM_ENV";
+    readonly MAX_ITERATIONS: "ELIZA_RLM_MAX_ITERATIONS";
+    readonly MAX_DEPTH: "ELIZA_RLM_MAX_DEPTH";
+    readonly VERBOSE: "ELIZA_RLM_VERBOSE";
+    readonly PYTHON_PATH: "ELIZA_RLM_PYTHON_PATH";
+    readonly MAX_RETRIES: "ELIZA_RLM_MAX_RETRIES";
+    readonly RETRY_BASE_DELAY: "ELIZA_RLM_RETRY_BASE_DELAY";
+    readonly RETRY_MAX_DELAY: "ELIZA_RLM_RETRY_MAX_DELAY";
+};
+
+/** RLM Client - communicates with Python subprocess via JSON-RPC IPC. */
+
+interface Logger {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+}
+declare function configFromEnv(env?: NodeJS.ProcessEnv): RLMConfig;
+declare class RLMClient {
+    private config;
+    private process;
+    private reader;
+    private requestId;
+    private pendingRequests;
+    private isReady;
+    private isAvailable;
+    private hasStartupError;
+    private logger;
+    private metrics;
+    private static readonly MAX_LATENCY_SAMPLES;
+    private latencies;
+    private latencyIndex;
+    private latencyCount;
+    private metricsCallback;
+    constructor(config?: Partial<RLMConfig>, logger?: Logger, strictValidation?: boolean);
+    private startServer;
+    private waitForReady;
+    private handleMessage;
+    private sendRequest;
+    private ensureServer;
+    get available(): boolean;
+    getMetrics(): RLMMetrics;
+    onMetrics(callback: MetricsCallback): void;
+    private updateMetrics;
+    static normalizeMessages(messages: string | RLMMessage[]): RLMMessage[];
+    infer(messages: string | RLMMessage[], opts?: RLMInferOptions): Promise<RLMResult>;
+    getStatus(): Promise<RLMStatusResponse>;
+    shutdown(): Promise<void>;
+}
+declare function stubResult(error?: string): RLMResult;
+
+/**
+ * RLM (Recursive Language Model) plugin for elizaOS.
+ *
+ * This plugin integrates Recursive Language Models into elizaOS, enabling
+ * LLMs to process arbitrarily long contexts through recursive self-calls
+ * in a REPL environment.
+ *
+ * Reference:
+ * - Paper: https://arxiv.org/abs/2512.24601
+ * - Implementation: https://github.com/alexzhang13/rlm
+ */
+
+/**
+ * Reset the client singleton. Useful for testing or forced reinitialization.
+ */
+declare function resetClient(): Promise<void>;
+/**
+ * RLM plugin definition.
+ */
+declare const rlmPlugin: Plugin;
+
+export { DEFAULT_CONFIG, ENV_VARS, type GenerateTextParams, RLMClient, type RLMConfig, type RLMInferOptions, type RLMMessage, type RLMMetadata, type RLMResult, type RLMStatusResponse, configFromEnv, rlmPlugin as default, resetClient, rlmPlugin, stubResult };

package/dist/index.js

@@ -0,0 +1,517 @@
+// index.ts
+import { ModelType, logger } from "@elizaos/core";
+
+// client.ts
+import { spawn } from "child_process";
+import * as path from "path";
+import * as readline from "readline";
+
+// types.ts
+var DEFAULT_CONFIG = {
+  backend: "gemini",
+  backendKwargs: {},
+  environment: "local",
+  maxIterations: 4,
+  maxDepth: 1,
+  verbose: false,
+  pythonPath: "python",
+  maxRetries: 3,
+  retryBaseDelay: 1e3,
+  retryMaxDelay: 3e4
+};
+var ENV_VARS = {
+  BACKEND: "ELIZA_RLM_BACKEND",
+  ENVIRONMENT: "ELIZA_RLM_ENV",
+  MAX_ITERATIONS: "ELIZA_RLM_MAX_ITERATIONS",
+  MAX_DEPTH: "ELIZA_RLM_MAX_DEPTH",
+  VERBOSE: "ELIZA_RLM_VERBOSE",
+  PYTHON_PATH: "ELIZA_RLM_PYTHON_PATH",
+  MAX_RETRIES: "ELIZA_RLM_MAX_RETRIES",
+  RETRY_BASE_DELAY: "ELIZA_RLM_RETRY_BASE_DELAY",
+  RETRY_MAX_DELAY: "ELIZA_RLM_RETRY_MAX_DELAY"
+};
+var VALID_BACKENDS = [
+  "openai",
+  "anthropic",
+  "gemini",
+  "groq",
+  "openrouter"
+];
+var VALID_ENVIRONMENTS = ["local", "docker", "modal", "prime"];
+var RLMConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RLMConfigError";
+  }
+};
+function validateConfig(config, strict = false) {
+  const errors = [];
+  if (config.backend !== void 0 && !VALID_BACKENDS.includes(config.backend)) {
+    errors.push(`Invalid backend '${config.backend}'. Valid options: ${VALID_BACKENDS.join(", ")}`);
+  }
+  if (config.environment !== void 0 && !VALID_ENVIRONMENTS.includes(config.environment)) {
+    errors.push(
+      `Invalid environment '${config.environment}'. Valid options: ${VALID_ENVIRONMENTS.join(", ")}`
+    );
+  }
+  if (config.maxIterations !== void 0 && config.maxIterations < 1) {
+    errors.push("maxIterations must be >= 1");
+  }
+  if (config.maxDepth !== void 0 && config.maxDepth < 1) {
+    errors.push("maxDepth must be >= 1");
+  }
+  if (config.maxRetries !== void 0 && config.maxRetries < 0) {
+    errors.push("maxRetries must be >= 0");
+  }
+  if (config.retryBaseDelay !== void 0 && config.retryBaseDelay < 0) {
+    errors.push("retryBaseDelay must be >= 0");
+  }
+  if (config.retryBaseDelay !== void 0 && config.retryMaxDelay !== void 0 && config.retryMaxDelay < config.retryBaseDelay) {
+    errors.push("retryMaxDelay must be >= retryBaseDelay");
+  }
+  if (strict && errors.length > 0) {
+    throw new RLMConfigError(errors.join("; "));
+  }
+  return errors;
+}
+
+// client.ts
+var defaultLogger = {
+  info: (msg, ...args) => console.log(`[RLM] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[RLM] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[RLM] ${msg}`, ...args),
+  debug: (msg, ...args) => console.debug(`[RLM] ${msg}`, ...args)
+};
+function configFromEnv(env2 = process.env) {
+  return {
+    backend: env2[ENV_VARS.BACKEND] ?? DEFAULT_CONFIG.backend,
+    backendKwargs: {},
+    environment: env2[ENV_VARS.ENVIRONMENT] ?? DEFAULT_CONFIG.environment,
+    maxIterations: Number.parseInt(env2[ENV_VARS.MAX_ITERATIONS] ?? "", 10) || DEFAULT_CONFIG.maxIterations,
+    maxDepth: Number.parseInt(env2[ENV_VARS.MAX_DEPTH] ?? "", 10) || DEFAULT_CONFIG.maxDepth,
+    verbose: ["1", "true", "yes"].includes((env2[ENV_VARS.VERBOSE] ?? "").toLowerCase()),
+    pythonPath: env2[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath,
+    maxRetries: Number.parseInt(env2[ENV_VARS.MAX_RETRIES] ?? "", 10) || DEFAULT_CONFIG.maxRetries,
+    retryBaseDelay: Number.parseInt(env2[ENV_VARS.RETRY_BASE_DELAY] ?? "", 10) || DEFAULT_CONFIG.retryBaseDelay,
+    retryMaxDelay: Number.parseInt(env2[ENV_VARS.RETRY_MAX_DELAY] ?? "", 10) || DEFAULT_CONFIG.retryMaxDelay
+  };
+}
+var RLMClient = class _RLMClient {
+  config;
+  process = null;
+  reader = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  isReady = false;
+  isAvailable = false;
+  hasStartupError = false;
+  logger;
+  metrics = {
+    totalRequests: 0,
+    successfulRequests: 0,
+    failedRequests: 0,
+    stubResponses: 0,
+    totalRetries: 0,
+    averageLatencyMs: 0,
+    p95LatencyMs: 0,
+    lastRequestTimestamp: 0
+  };
+  static MAX_LATENCY_SAMPLES = 1e3;
+  latencies = new Array(_RLMClient.MAX_LATENCY_SAMPLES).fill(0);
+  latencyIndex = 0;
+  latencyCount = 0;
+  metricsCallback = null;
+  constructor(config, logger2, strictValidation = false) {
+    this.config = { ...configFromEnv(), ...config };
+    this.logger = logger2 ?? defaultLogger;
+    const errors = validateConfig(this.config);
+    if (errors.length > 0) {
+      if (strictValidation) {
+        throw new Error(`RLM configuration invalid: ${errors.join("; ")}`);
+      }
+      for (const error of errors) {
+        this.logger.warn(`Configuration warning: ${error}`);
+      }
+    }
+  }
+  async startServer() {
+    if (this.process) return;
+    this.hasStartupError = false;
+    this.logger.debug(
+      `Starting RLM server: ${this.config.pythonPath} -m elizaos_plugin_rlm.server`
+    );
+    try {
+      this.process = spawn(this.config.pythonPath, ["-m", "elizaos_plugin_rlm.server"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          [ENV_VARS.BACKEND]: this.config.backend,
+          [ENV_VARS.ENVIRONMENT]: this.config.environment,
+          [ENV_VARS.MAX_ITERATIONS]: String(this.config.maxIterations),
+          [ENV_VARS.MAX_DEPTH]: String(this.config.maxDepth),
+          [ENV_VARS.VERBOSE]: this.config.verbose ? "true" : "false"
+        },
+        cwd: path.join(__dirname, "..", "python")
+      });
+    } catch (error) {
+      this.logger.warn(`Failed to start RLM server: ${error}`);
+      this.isAvailable = false;
+      return;
+    }
+    if (!this.process.stdout || !this.process.stdin) {
+      this.logger.warn("RLM server process missing stdio streams");
+      this.isAvailable = false;
+      return;
+    }
+    this.reader = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+    this.reader.on("line", (line) => {
+      this.handleMessage(line);
+    });
+    this.process.stderr?.on("data", (data) => {
+      this.logger.debug(`RLM server stderr: ${data.toString()}`);
+    });
+    this.process.on("error", (error) => {
+      this.logger.error(`RLM server error: ${error.message}`);
+      this.isAvailable = false;
+      this.hasStartupError = true;
+    });
+    this.process.on("exit", (code) => {
+      this.logger.debug(`RLM server exited with code ${code}`);
+      this.isReady = false;
+      this.isAvailable = false;
+      this.process = null;
+    });
+    await this.waitForReady();
+  }
+  waitForReady() {
+    return new Promise((resolve, reject) => {
+      const TIMEOUT_MS = 1e4;
+      const POLL_INTERVAL_MS = 100;
+      const deadline = Date.now() + TIMEOUT_MS;
+      const checkReady = () => {
+        if (this.isReady) {
+          resolve();
+        } else if (!this.process || this.hasStartupError) {
+          reject(new Error("RLM server process failed before ready"));
+        } else if (Date.now() > deadline) {
+          reject(new Error("RLM server startup timeout"));
+        } else {
+          setTimeout(checkReady, POLL_INTERVAL_MS);
+        }
+      };
+      checkReady();
+    });
+  }
+  handleMessage(line) {
+    try {
+      const message = JSON.parse(line);
+      if ("ready" in message) {
+        const readyMsg = message;
+        this.isReady = true;
+        this.isAvailable = readyMsg.available;
+        this.logger.info(`RLM server ready, available: ${this.isAvailable}`);
+        return;
+      }
+      const response = message;
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to parse RLM server message: ${line}`);
+    }
+  }
+  async sendRequest(method, params = {}) {
+    await this.ensureServer();
+    if (!this.process?.stdin) {
+      throw new Error("RLM server not running");
+    }
+    const id = ++this.requestId;
+    const request = { id, method, params };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`RLM request timeout: ${method}`));
+      }, 6e4);
+      this.pendingRequests.set(id, {
+        resolve: (response) => {
+          clearTimeout(timeout);
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve(response.result);
+          }
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+      this.process?.stdin?.write(`${JSON.stringify(request)}
+`);
+    });
+  }
+  async ensureServer() {
+    if (!this.process || !this.isReady) {
+      await this.startServer();
+    }
+  }
+  get available() {
+    return this.isAvailable;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  onMetrics(callback) {
+    this.metricsCallback = callback;
+  }
+  updateMetrics(latencyMs, success, isStub, error) {
+    this.metrics.totalRequests++;
+    this.metrics.lastRequestTimestamp = Date.now();
+    if (isStub) {
+      this.metrics.stubResponses++;
+    } else if (success) {
+      this.metrics.successfulRequests++;
+    } else {
+      this.metrics.failedRequests++;
+      this.metrics.lastErrorTimestamp = Date.now();
+      this.metrics.lastError = error;
+    }
+    this.latencies[this.latencyIndex] = latencyMs;
+    this.latencyIndex = (this.latencyIndex + 1) % _RLMClient.MAX_LATENCY_SAMPLES;
+    this.latencyCount = Math.min(this.latencyCount + 1, _RLMClient.MAX_LATENCY_SAMPLES);
+    if (this.latencyCount > 0) {
+      const valid = this.latencies.slice(0, this.latencyCount);
+      this.metrics.averageLatencyMs = valid.reduce((a, b) => a + b, 0) / this.latencyCount;
+      this.metrics.p95LatencyMs = [...valid].sort((a, b) => a - b)[Math.floor(valid.length * 0.95)] ?? 0;
+    }
+    this.metricsCallback?.(this.getMetrics());
+  }
+  static normalizeMessages(messages) {
+    return typeof messages === "string" ? [{ role: "user", content: messages }] : messages;
+  }
+  async infer(messages, opts) {
+    const startTime = Date.now();
+    const { maxRetries = 3, retryBaseDelay = 1e3, retryMaxDelay = 3e4 } = this.config;
+    const RETRYABLE_PATTERNS = ["timeout", "rate limit", "connection", "503", "429", "econnreset"];
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        await this.ensureServer();
+        if (!this.isReady) {
+          this.updateMetrics(Date.now() - startTime, true, true);
+          return stubResult();
+        }
+        const result = await this.sendRequest("infer", {
+          messages: _RLMClient.normalizeMessages(messages),
+          opts: opts ?? {}
+        });
+        this.updateMetrics(Date.now() - startTime, true, false);
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const isRetryable = RETRYABLE_PATTERNS.some(
+          (p) => lastError?.message.toLowerCase().includes(p)
+        );
+        if (!isRetryable || attempt === maxRetries - 1) {
+          this.logger.error(`RLM inference failed after ${attempt + 1} attempts: ${error}`);
+          this.updateMetrics(Date.now() - startTime, true, true, lastError.message);
+          return stubResult(lastError.message);
+        }
+        const delay = Math.min(retryBaseDelay * 2 ** attempt, retryMaxDelay) * (0.75 + Math.random() * 0.5);
+        this.metrics.totalRetries++;
+        this.logger.warn(
+          `RLM attempt ${attempt + 1}/${maxRetries} failed. Retrying in ${Math.round(delay)}ms`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    this.updateMetrics(Date.now() - startTime, false, false, lastError?.message);
+    return stubResult(lastError?.message);
+  }
+  async getStatus() {
+    try {
+      await this.ensureServer();
+      return await this.sendRequest("status");
+    } catch {
+      return {
+        available: false,
+        backend: this.config.backend,
+        environment: this.config.environment,
+        maxIterations: this.config.maxIterations,
+        maxDepth: this.config.maxDepth
+      };
+    }
+  }
+  async shutdown() {
+    if (!this.process) return;
+    try {
+      await this.sendRequest("shutdown");
+    } catch {
+    }
+    this.reader?.close();
+    this.process?.kill();
+    this.process = null;
+    this.isReady = false;
+    this.isAvailable = false;
+  }
+};
+function stubResult(error) {
+  return {
+    text: "[RLM STUB] RLM backend not available",
+    metadata: { stub: true, error }
+  };
+}
+
+// index.ts
+var env = typeof process !== "undefined" ? process.env : {};
+var clientState = {
+  client: null,
+  initPromise: null,
+  configHash: null
+};
+function computeConfigHash(config) {
+  const key = [
+    config.backend ?? "",
+    config.environment ?? "",
+    String(config.maxIterations ?? ""),
+    String(config.maxDepth ?? ""),
+    config.pythonPath ?? ""
+  ].join("|");
+  return key;
+}
+function getOrCreateClient(runtime) {
+  const runtimeConfig = runtime.rlmConfig;
+  const configHash = computeConfigHash(runtimeConfig ?? {});
+  if (clientState.client && clientState.configHash !== configHash) {
+    logger.info("[RLM] Config changed, recreating client");
+    clientState.client.shutdown().catch((err) => {
+      logger.warn("[RLM] Error shutting down old client:", err);
+    });
+    clientState.client = null;
+    clientState.initPromise = null;
+  }
+  if (clientState.client) {
+    return clientState.client;
+  }
+  const client = new RLMClient(runtimeConfig);
+  clientState.client = client;
+  clientState.configHash = configHash;
+  return client;
+}
+async function resetClient() {
+  if (clientState.client) {
+    await clientState.client.shutdown();
+  }
+  clientState.client = null;
+  clientState.initPromise = null;
+  clientState.configHash = null;
+}
+async function handleTextGeneration(runtime, params) {
+  const client = getOrCreateClient(runtime);
+  const input = params.prompt ?? "";
+  const opts = {
+    maxTokens: params.maxTokens,
+    temperature: params.temperature,
+    topP: params.topP,
+    stopSequences: params.stopSequences,
+    user: params.user
+  };
+  const cleanOpts = Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== void 0));
+  const result = await client.infer(input, cleanOpts);
+  return result.text;
+}
+var rlmPlugin = {
+  name: "rlm",
+  description: "RLM (Recursive Language Model) adapter for elizaOS - enables processing of arbitrarily long contexts through recursive self-calls",
+  config: {
+    [ENV_VARS.BACKEND]: env[ENV_VARS.BACKEND] ?? DEFAULT_CONFIG.backend,
+    [ENV_VARS.ENVIRONMENT]: env[ENV_VARS.ENVIRONMENT] ?? DEFAULT_CONFIG.environment,
+    [ENV_VARS.MAX_ITERATIONS]: env[ENV_VARS.MAX_ITERATIONS] ?? String(DEFAULT_CONFIG.maxIterations),
+    [ENV_VARS.MAX_DEPTH]: env[ENV_VARS.MAX_DEPTH] ?? String(DEFAULT_CONFIG.maxDepth),
+    [ENV_VARS.VERBOSE]: env[ENV_VARS.VERBOSE] ?? "false",
+    [ENV_VARS.PYTHON_PATH]: env[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath
+  },
+  async init(config, runtime) {
+    logger.info("[RLM] Initializing RLM plugin");
+    runtime.rlmConfig = {
+      backend: config[ENV_VARS.BACKEND] ?? DEFAULT_CONFIG.backend,
+      environment: config[ENV_VARS.ENVIRONMENT] ?? DEFAULT_CONFIG.environment,
+      maxIterations: Number.parseInt(config[ENV_VARS.MAX_ITERATIONS] ?? "", 10) || DEFAULT_CONFIG.maxIterations,
+      maxDepth: Number.parseInt(config[ENV_VARS.MAX_DEPTH] ?? "", 10) || DEFAULT_CONFIG.maxDepth,
+      verbose: ["1", "true", "yes"].includes((config[ENV_VARS.VERBOSE] ?? "").toLowerCase()),
+      pythonPath: config[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath
+    };
+    const client = getOrCreateClient(runtime);
+    const status = await client.getStatus();
+    if (status.available) {
+      logger.info(`[RLM] Backend available: ${status.backend}`);
+    } else {
+      logger.warn("[RLM] Backend not available - running in stub mode");
+    }
+  },
+  models: {
+    [ModelType.TEXT_SMALL]: handleTextGeneration,
+    [ModelType.TEXT_LARGE]: handleTextGeneration,
+    [ModelType.TEXT_REASONING_SMALL]: handleTextGeneration,
+    [ModelType.TEXT_REASONING_LARGE]: handleTextGeneration,
+    [ModelType.TEXT_COMPLETION]: handleTextGeneration
+  },
+  tests: [
+    {
+      name: "rlm_plugin_tests",
+      tests: [
+        {
+          name: "rlm_test_stub_mode",
+          fn: async (_runtime) => {
+            const result = stubResult();
+            if (!result.metadata.stub) {
+              throw new Error("Stub result should have stub=true");
+            }
+            logger.info("[RLM Test] Stub mode test passed");
+          }
+        },
+        {
+          name: "rlm_test_text_generation",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType.TEXT_LARGE, {
+              prompt: "Say 'hello' in exactly one word."
+            });
+            if (typeof text !== "string") {
+              throw new Error("TEXT_LARGE should return string");
+            }
+            logger.info(`[RLM Test] TEXT_LARGE generated: "${text.substring(0, 50)}..."`);
+          }
+        },
+        {
+          name: "rlm_test_message_format",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType.TEXT_LARGE, {
+              prompt: "What is 2 + 2?"
+            });
+            if (typeof text !== "string") {
+              throw new Error("TEXT_LARGE with prompt should return string");
+            }
+            logger.info("[RLM Test] Message format test passed");
+          }
+        }
+      ]
+    }
+  ]
+};
+var index_default = rlmPlugin;
+export {
+  DEFAULT_CONFIG,
+  ENV_VARS,
+  RLMClient,
+  configFromEnv,
+  index_default as default,
+  resetClient,
+  rlmPlugin,
+  stubResult
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts","../client.ts","../types.ts"],"sourcesContent":["/**\n * RLM (Recursive Language Model) plugin for elizaOS.\n *\n * This plugin integrates Recursive Language Models into elizaOS, enabling\n * LLMs to process arbitrarily long contexts through recursive self-calls\n * in a REPL environment.\n *\n * Reference:\n * - Paper: https://arxiv.org/abs/2512.24601\n * - Implementation: https://github.com/alexzhang13/rlm\n */\n\nimport type { GenerateTextParams, IAgentRuntime, Plugin } from \"@elizaos/core\";\nimport { ModelType, logger } from \"@elizaos/core\";\n\nimport { RLMClient, stubResult } from \"./client\";\nimport type { RLMConfig } from \"./types\";\nimport { DEFAULT_CONFIG, ENV_VARS } from \"./types\";\n\n// Safe env access for browser/non-Node environments\nconst env: Record<string, string | undefined> = typeof process !== \"undefined\" ? process.env : {};\n\n// ============================================================================\n// Thread-safe Singleton Client Management\n// ============================================================================\n\n/**\n * Singleton state for thread-safe client initialization.\n *\n * In concurrent environments, multiple requests could try to initialize\n * the client simultaneously. We use a promise-based lock to ensure\n * only one initialization happens.\n */\ninterface ClientState {\n  client: RLMClient | null;\n  initPromise: Promise<RLMClient> | null;\n  configHash: string | null;\n}\n\nconst clientState: ClientState = {\n  client: null,\n  initPromise: null,\n  configHash: null,\n};\n\n/**\n * Compute a simple hash of config for detecting changes.\n */\nfunction computeConfigHash(config: Partial<RLMConfig>): string {\n  const key = [\n    config.backend ?? \"\",\n    config.environment ?? \"\",\n    String(config.maxIterations ?? \"\"),\n    String(config.maxDepth ?? \"\"),\n    config.pythonPath ?? \"\",\n  ].join(\"|\");\n  return key;\n}\n\n/**\n * Get or create the shared RLM client instance (thread-safe).\n *\n * This implementation ensures:\n * 1. Only one client is created even under concurrent initialization\n * 2. Config changes are detected and client is recreated\n * 3. Initialization errors are properly handled\n */\nfunction getOrCreateClient(runtime: IAgentRuntime): RLMClient {\n  // Get config from runtime or environment\n  const runtimeConfig = (runtime as unknown as Record<string, unknown>).rlmConfig as\n    | Partial<RLMConfig>\n    | undefined;\n  const configHash = computeConfigHash(runtimeConfig ?? {});\n\n  // Check if config changed - need to recreate client\n  if (clientState.client && clientState.configHash !== configHash) {\n    logger.info(\"[RLM] Config changed, recreating client\");\n    // Shutdown old client (fire and forget)\n    clientState.client.shutdown().catch((err) => {\n      logger.warn(\"[RLM] Error shutting down old client:\", err);\n    });\n    clientState.client = null;\n    clientState.initPromise = null;\n  }\n\n  // Fast path: client already exists with same config\n  if (clientState.client) {\n    return clientState.client;\n  }\n\n  // Slow path: need to create client\n  // Create synchronously to avoid Promise in synchronous getter\n  const client = new RLMClient(runtimeConfig);\n  clientState.client = client;\n  clientState.configHash = configHash;\n\n  return client;\n}\n\n/**\n * Reset the client singleton. Useful for testing or forced reinitialization.\n */\nexport async function resetClient(): Promise<void> {\n  if (clientState.client) {\n    await clientState.client.shutdown();\n  }\n  clientState.client = null;\n  clientState.initPromise = null;\n  clientState.configHash = null;\n}\n\n/**\n * Handle text generation using RLM.\n */\nasync function handleTextGeneration(\n  runtime: IAgentRuntime,\n  params: GenerateTextParams,\n): Promise<string> {\n  const client = getOrCreateClient(runtime);\n\n  // Use prompt from params\n  const input = params.prompt ?? \"\";\n\n  const opts = {\n    maxTokens: params.maxTokens,\n    temperature: params.temperature,\n    topP: params.topP,\n    stopSequences: params.stopSequences,\n    user: params.user,\n  };\n\n  // Remove undefined values\n  const cleanOpts = Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== undefined));\n\n  const result = await client.infer(input, cleanOpts);\n  return result.text;\n}\n\n/**\n * RLM plugin definition.\n */\nexport const rlmPlugin: Plugin = {\n  name: \"rlm\",\n  description:\n    \"RLM (Recursive Language Model) adapter for elizaOS - enables processing of arbitrarily long contexts through recursive self-calls\",\n\n  config: {\n    [ENV_VARS.BACKEND]: env[ENV_VARS.BACKEND] ?? DEFAULT_CONFIG.backend,\n    [ENV_VARS.ENVIRONMENT]: env[ENV_VARS.ENVIRONMENT] ?? DEFAULT_CONFIG.environment,\n    [ENV_VARS.MAX_ITERATIONS]: env[ENV_VARS.MAX_ITERATIONS] ?? String(DEFAULT_CONFIG.maxIterations),\n    [ENV_VARS.MAX_DEPTH]: env[ENV_VARS.MAX_DEPTH] ?? String(DEFAULT_CONFIG.maxDepth),\n    [ENV_VARS.VERBOSE]: env[ENV_VARS.VERBOSE] ?? \"false\",\n    [ENV_VARS.PYTHON_PATH]: env[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath,\n  },\n\n  async init(config: Record<string, string>, runtime: IAgentRuntime): Promise<void> {\n    logger.info(\"[RLM] Initializing RLM plugin\");\n\n    // Store config on runtime\n    (runtime as unknown as Record<string, unknown>).rlmConfig = {\n      backend: config[ENV_VARS.BACKEND] ?? DEFAULT_CONFIG.backend,\n      environment: config[ENV_VARS.ENVIRONMENT] ?? DEFAULT_CONFIG.environment,\n      maxIterations:\n        Number.parseInt(config[ENV_VARS.MAX_ITERATIONS] ?? \"\", 10) || DEFAULT_CONFIG.maxIterations,\n      maxDepth: Number.parseInt(config[ENV_VARS.MAX_DEPTH] ?? \"\", 10) || DEFAULT_CONFIG.maxDepth,\n      verbose: [\"1\", \"true\", \"yes\"].includes((config[ENV_VARS.VERBOSE] ?? \"\").toLowerCase()),\n      pythonPath: config[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath,\n    };\n\n    // Pre-initialize client\n    const client = getOrCreateClient(runtime);\n    const status = await client.getStatus();\n\n    if (status.available) {\n      logger.info(`[RLM] Backend available: ${status.backend}`);\n    } else {\n      logger.warn(\"[RLM] Backend not available - running in stub mode\");\n    }\n  },\n\n  models: {\n    [ModelType.TEXT_SMALL]: handleTextGeneration,\n    [ModelType.TEXT_LARGE]: handleTextGeneration,\n    [ModelType.TEXT_REASONING_SMALL]: handleTextGeneration,\n    [ModelType.TEXT_REASONING_LARGE]: handleTextGeneration,\n    [ModelType.TEXT_COMPLETION]: handleTextGeneration,\n  },\n\n  tests: [\n    {\n      name: \"rlm_plugin_tests\",\n      tests: [\n        {\n          name: \"rlm_test_stub_mode\",\n          fn: async (_runtime: IAgentRuntime): Promise<void> => {\n            // Test that stub mode works\n            const result = stubResult();\n            if (!result.metadata.stub) {\n              throw new Error(\"Stub result should have stub=true\");\n            }\n            logger.info(\"[RLM Test] Stub mode test passed\");\n          },\n        },\n        {\n          name: \"rlm_test_text_generation\",\n          fn: async (runtime: IAgentRuntime): Promise<void> => {\n            const text = await runtime.useModel(ModelType.TEXT_LARGE, {\n              prompt: \"Say 'hello' in exactly one word.\",\n            });\n\n            if (typeof text !== \"string\") {\n              throw new Error(\"TEXT_LARGE should return string\");\n            }\n\n            logger.info(`[RLM Test] TEXT_LARGE generated: \"${text.substring(0, 50)}...\"`);\n          },\n        },\n        {\n          name: \"rlm_test_message_format\",\n          fn: async (runtime: IAgentRuntime): Promise<void> => {\n            const text = await runtime.useModel(ModelType.TEXT_LARGE, {\n              prompt: \"What is 2 + 2?\",\n            });\n\n            if (typeof text !== \"string\") {\n              throw new Error(\"TEXT_LARGE with prompt should return string\");\n            }\n\n            logger.info(\"[RLM Test] Message format test passed\");\n          },\n        },\n      ],\n    },\n  ],\n};\n\nexport default rlmPlugin;\n\n// Re-export types and client\nexport { configFromEnv, RLMClient, stubResult } from \"./client\";\nexport type {\n  GenerateTextParams,\n  RLMConfig,\n  RLMInferOptions,\n  RLMMessage,\n  RLMMetadata,\n  RLMResult,\n  RLMStatusResponse,\n} from \"./types\";\nexport { DEFAULT_CONFIG, ENV_VARS } from \"./types\";\n","/** RLM Client - communicates with Python subprocess via JSON-RPC IPC. */\n\nimport { type ChildProcess, spawn } from \"node:child_process\";\nimport * as path from \"node:path\";\nimport * as readline from \"node:readline\";\n\nimport type {\n  IPCReadyMessage,\n  IPCRequest,\n  IPCResponse,\n  MetricsCallback,\n  RLMConfig,\n  RLMInferOptions,\n  RLMMessage,\n  RLMMetrics,\n  RLMResult,\n  RLMStatusResponse,\n} from \"./types\";\nimport { DEFAULT_CONFIG, ENV_VARS, validateConfig } from \"./types\";\n\nexport { DEFAULT_CONFIG };\nexport type { RLMMetrics, MetricsCallback };\n\ninterface Logger {\n  info: (message: string, ...args: unknown[]) => void;\n  warn: (message: string, ...args: unknown[]) => void;\n  error: (message: string, ...args: unknown[]) => void;\n  debug: (message: string, ...args: unknown[]) => void;\n}\n\nconst defaultLogger: Logger = {\n  info: (msg, ...args) => console.log(`[RLM] ${msg}`, ...args),\n  warn: (msg, ...args) => console.warn(`[RLM] ${msg}`, ...args),\n  error: (msg, ...args) => console.error(`[RLM] ${msg}`, ...args),\n  debug: (msg, ...args) => console.debug(`[RLM] ${msg}`, ...args),\n};\n\nexport function configFromEnv(env: NodeJS.ProcessEnv = process.env): RLMConfig {\n  return {\n    backend: (env[ENV_VARS.BACKEND] as RLMConfig[\"backend\"]) ?? DEFAULT_CONFIG.backend,\n    backendKwargs: {},\n    environment:\n      (env[ENV_VARS.ENVIRONMENT] as RLMConfig[\"environment\"]) ?? DEFAULT_CONFIG.environment,\n    maxIterations:\n      Number.parseInt(env[ENV_VARS.MAX_ITERATIONS] ?? \"\", 10) || DEFAULT_CONFIG.maxIterations,\n    maxDepth: Number.parseInt(env[ENV_VARS.MAX_DEPTH] ?? \"\", 10) || DEFAULT_CONFIG.maxDepth,\n    verbose: [\"1\", \"true\", \"yes\"].includes((env[ENV_VARS.VERBOSE] ?? \"\").toLowerCase()),\n    pythonPath: env[ENV_VARS.PYTHON_PATH] ?? DEFAULT_CONFIG.pythonPath,\n    maxRetries: Number.parseInt(env[ENV_VARS.MAX_RETRIES] ?? \"\", 10) || DEFAULT_CONFIG.maxRetries,\n    retryBaseDelay:\n      Number.parseInt(env[ENV_VARS.RETRY_BASE_DELAY] ?? \"\", 10) || DEFAULT_CONFIG.retryBaseDelay,\n    retryMaxDelay:\n      Number.parseInt(env[ENV_VARS.RETRY_MAX_DELAY] ?? \"\", 10) || DEFAULT_CONFIG.retryMaxDelay,\n  };\n}\n\nexport class RLMClient {\n  private config: RLMConfig;\n  private process: ChildProcess | null = null;\n  private reader: readline.Interface | null = null;\n  private requestId = 0;\n  private pendingRequests = new Map<\n    number,\n    { resolve: (value: IPCResponse) => void; reject: (error: Error) => void }\n  >();\n  private isReady = false;\n  private isAvailable = false;\n  private hasStartupError = false;\n  private logger: Logger;\n  private metrics: RLMMetrics = {\n    totalRequests: 0,\n    successfulRequests: 0,\n    failedRequests: 0,\n    stubResponses: 0,\n    totalRetries: 0,\n    averageLatencyMs: 0,\n    p95LatencyMs: 0,\n    lastRequestTimestamp: 0,\n  };\n  private static readonly MAX_LATENCY_SAMPLES = 1000;\n  private latencies: number[] = new Array(RLMClient.MAX_LATENCY_SAMPLES).fill(0);\n  private latencyIndex = 0;\n  private latencyCount = 0;\n  private metricsCallback: MetricsCallback | null = null;\n\n  constructor(config?: Partial<RLMConfig>, logger?: Logger, strictValidation = false) {\n    this.config = { ...configFromEnv(), ...config };\n    this.logger = logger ?? defaultLogger;\n\n    const errors = validateConfig(this.config);\n    if (errors.length > 0) {\n      if (strictValidation) {\n        throw new Error(`RLM configuration invalid: ${errors.join(\"; \")}`);\n      }\n      for (const error of errors) {\n        this.logger.warn(`Configuration warning: ${error}`);\n      }\n    }\n  }\n\n  private async startServer(): Promise<void> {\n    if (this.process) return;\n    this.hasStartupError = false;\n\n    this.logger.debug(\n      `Starting RLM server: ${this.config.pythonPath} -m elizaos_plugin_rlm.server`,\n    );\n\n    try {\n      this.process = spawn(this.config.pythonPath, [\"-m\", \"elizaos_plugin_rlm.server\"], {\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n        env: {\n          ...process.env,\n          [ENV_VARS.BACKEND]: this.config.backend,\n          [ENV_VARS.ENVIRONMENT]: this.config.environment,\n          [ENV_VARS.MAX_ITERATIONS]: String(this.config.maxIterations),\n          [ENV_VARS.MAX_DEPTH]: String(this.config.maxDepth),\n          [ENV_VARS.VERBOSE]: this.config.verbose ? \"true\" : \"false\",\n        },\n        cwd: path.join(__dirname, \"..\", \"python\"),\n      });\n    } catch (error) {\n      this.logger.warn(`Failed to start RLM server: ${error}`);\n      this.isAvailable = false;\n      return;\n    }\n\n    if (!this.process.stdout || !this.process.stdin) {\n      this.logger.warn(\"RLM server process missing stdio streams\");\n      this.isAvailable = false;\n      return;\n    }\n\n    // Set up line reader for responses\n    this.reader = readline.createInterface({\n      input: this.process.stdout,\n      crlfDelay: Number.POSITIVE_INFINITY,\n    });\n\n    // Handle incoming messages\n    this.reader.on(\"line\", (line: string) => {\n      this.handleMessage(line);\n    });\n\n    // Handle errors\n    this.process.stderr?.on(\"data\", (data: Buffer) => {\n      this.logger.debug(`RLM server stderr: ${data.toString()}`);\n    });\n\n    this.process.on(\"error\", (error: Error) => {\n      this.logger.error(`RLM server error: ${error.message}`);\n      this.isAvailable = false;\n      this.hasStartupError = true;\n    });\n\n    this.process.on(\"exit\", (code: number | null) => {\n      this.logger.debug(`RLM server exited with code ${code}`);\n      this.isReady = false;\n      this.isAvailable = false;\n      this.process = null;\n    });\n\n    await this.waitForReady();\n  }\n\n  private waitForReady(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const TIMEOUT_MS = 10000;\n      const POLL_INTERVAL_MS = 100;\n      const deadline = Date.now() + TIMEOUT_MS;\n\n      const checkReady = () => {\n        if (this.isReady) {\n          resolve();\n        } else if (!this.process || this.hasStartupError) {\n          reject(new Error(\"RLM server process failed before ready\"));\n        } else if (Date.now() > deadline) {\n          reject(new Error(\"RLM server startup timeout\"));\n        } else {\n          setTimeout(checkReady, POLL_INTERVAL_MS);\n        }\n      };\n      checkReady();\n    });\n  }\n\n  private handleMessage(line: string): void {\n    try {\n      const message = JSON.parse(line) as IPCResponse | IPCReadyMessage;\n\n      // Check for ready message\n      if (\"ready\" in message) {\n        const readyMsg = message as IPCReadyMessage;\n        this.isReady = true;\n        this.isAvailable = readyMsg.available;\n        this.logger.info(`RLM server ready, available: ${this.isAvailable}`);\n        return;\n      }\n\n      // Handle response\n      const response = message as IPCResponse;\n      const pending = this.pendingRequests.get(response.id);\n      if (pending) {\n        this.pendingRequests.delete(response.id);\n        pending.resolve(response);\n      }\n    } catch (error) {\n      this.logger.error(`Failed to parse RLM server message: ${line}`);\n    }\n  }\n\n  private async sendRequest<T>(\n    method: IPCRequest[\"method\"],\n    params: Record<string, unknown> = {},\n  ): Promise<T> {\n    await this.ensureServer();\n\n    if (!this.process?.stdin) {\n      throw new Error(\"RLM server not running\");\n    }\n\n    const id = ++this.requestId;\n    const request: IPCRequest = { id, method, params };\n\n    return new Promise((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.pendingRequests.delete(id);\n        reject(new Error(`RLM request timeout: ${method}`));\n      }, 60000);\n\n      this.pendingRequests.set(id, {\n        resolve: (response: IPCResponse) => {\n          clearTimeout(timeout);\n          if (response.error) {\n            reject(new Error(response.error));\n          } else {\n            resolve(response.result as T);\n          }\n        },\n        reject: (error: Error) => {\n          clearTimeout(timeout);\n          reject(error);\n        },\n      });\n\n      this.process?.stdin?.write(`${JSON.stringify(request)}\\n`);\n    });\n  }\n\n  private async ensureServer(): Promise<void> {\n    if (!this.process || !this.isReady) {\n      await this.startServer();\n    }\n  }\n\n  get available(): boolean {\n    return this.isAvailable;\n  }\n\n  getMetrics(): RLMMetrics {\n    return { ...this.metrics };\n  }\n\n  onMetrics(callback: MetricsCallback): void {\n    this.metricsCallback = callback;\n  }\n\n  private updateMetrics(\n    latencyMs: number,\n    success: boolean,\n    isStub: boolean,\n    error?: string,\n  ): void {\n    this.metrics.totalRequests++;\n    this.metrics.lastRequestTimestamp = Date.now();\n\n    if (isStub) {\n      this.metrics.stubResponses++;\n    } else if (success) {\n      this.metrics.successfulRequests++;\n    } else {\n      this.metrics.failedRequests++;\n      this.metrics.lastErrorTimestamp = Date.now();\n      this.metrics.lastError = error;\n    }\n\n    // Track latency in circular buffer\n    this.latencies[this.latencyIndex] = latencyMs;\n    this.latencyIndex = (this.latencyIndex + 1) % RLMClient.MAX_LATENCY_SAMPLES;\n    this.latencyCount = Math.min(this.latencyCount + 1, RLMClient.MAX_LATENCY_SAMPLES);\n\n    // Calculate stats from valid samples\n    if (this.latencyCount > 0) {\n      const valid = this.latencies.slice(0, this.latencyCount);\n      this.metrics.averageLatencyMs = valid.reduce((a, b) => a + b, 0) / this.latencyCount;\n      this.metrics.p95LatencyMs =\n        [...valid].sort((a, b) => a - b)[Math.floor(valid.length * 0.95)] ?? 0;\n    }\n\n    this.metricsCallback?.(this.getMetrics());\n  }\n\n  static normalizeMessages(messages: string | RLMMessage[]): RLMMessage[] {\n    return typeof messages === \"string\" ? [{ role: \"user\", content: messages }] : messages;\n  }\n\n  async infer(messages: string | RLMMessage[], opts?: RLMInferOptions): Promise<RLMResult> {\n    const startTime = Date.now();\n    const { maxRetries = 3, retryBaseDelay = 1000, retryMaxDelay = 30000 } = this.config;\n    const RETRYABLE_PATTERNS = [\"timeout\", \"rate limit\", \"connection\", \"503\", \"429\", \"econnreset\"];\n\n    let lastError: Error | null = null;\n\n    for (let attempt = 0; attempt < maxRetries; attempt++) {\n      try {\n        await this.ensureServer();\n\n        if (!this.isReady) {\n          this.updateMetrics(Date.now() - startTime, true, true);\n          return stubResult();\n        }\n\n        const result = await this.sendRequest<RLMResult>(\"infer\", {\n          messages: RLMClient.normalizeMessages(messages),\n          opts: opts ?? {},\n        });\n\n        this.updateMetrics(Date.now() - startTime, true, false);\n        return result;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n        const isRetryable = RETRYABLE_PATTERNS.some((p) =>\n          lastError?.message.toLowerCase().includes(p),\n        );\n\n        if (!isRetryable || attempt === maxRetries - 1) {\n          this.logger.error(`RLM inference failed after ${attempt + 1} attempts: ${error}`);\n          this.updateMetrics(Date.now() - startTime, true, true, lastError.message);\n          return stubResult(lastError.message);\n        }\n\n        const delay =\n          Math.min(retryBaseDelay * 2 ** attempt, retryMaxDelay) * (0.75 + Math.random() * 0.5);\n        this.metrics.totalRetries++;\n        this.logger.warn(\n          `RLM attempt ${attempt + 1}/${maxRetries} failed. Retrying in ${Math.round(delay)}ms`,\n        );\n        await new Promise((resolve) => setTimeout(resolve, delay));\n      }\n    }\n\n    this.updateMetrics(Date.now() - startTime, false, false, lastError?.message);\n    return stubResult(lastError?.message);\n  }\n\n  async getStatus(): Promise<RLMStatusResponse> {\n    try {\n      await this.ensureServer();\n      return await this.sendRequest<RLMStatusResponse>(\"status\");\n    } catch {\n      return {\n        available: false,\n        backend: this.config.backend,\n        environment: this.config.environment,\n        maxIterations: this.config.maxIterations,\n        maxDepth: this.config.maxDepth,\n      };\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    if (!this.process) return;\n    try {\n      await this.sendRequest(\"shutdown\");\n    } catch {\n      /* ignore */\n    }\n    this.reader?.close();\n    this.process?.kill();\n    this.process = null;\n    this.isReady = false;\n    this.isAvailable = false;\n  }\n}\n\nexport function stubResult(error?: string): RLMResult {\n  return {\n    text: \"[RLM STUB] RLM backend not available\",\n    metadata: { stub: true, error },\n  };\n}\n","/** Types for the RLM (Recursive Language Model) plugin. */\n\nexport type RLMBackend = \"openai\" | \"anthropic\" | \"gemini\" | \"groq\" | \"openrouter\";\nexport type RLMEnvironment = \"local\" | \"docker\" | \"modal\" | \"prime\";\n\nexport interface RLMConfig {\n  backend: RLMBackend;\n  backendKwargs: Record<string, string>;\n  environment: RLMEnvironment;\n  maxIterations: number;\n  maxDepth: number;\n  verbose: boolean;\n  pythonPath: string;\n  maxRetries?: number;\n  retryBaseDelay?: number;\n  retryMaxDelay?: number;\n}\n\nexport interface RLMMessage {\n  role: \"user\" | \"assistant\" | \"system\";\n  content: string;\n}\n\nexport interface RLMMetadata {\n  stub: boolean;\n  iterations?: number;\n  depth?: number;\n  error?: string;\n}\n\nexport interface RLMResult {\n  text: string;\n  metadata: RLMMetadata;\n}\n\nexport interface RLMInferOptions {\n  /** Model identifier for this request */\n  model?: string;\n  /** Maximum tokens to generate */\n  maxTokens?: number;\n  /** Sampling temperature */\n  temperature?: number;\n  /** Top-p sampling parameter */\n  topP?: number;\n  /** Stop sequences */\n  stopSequences?: string[];\n  /** User identifier for tracking */\n  user?: string;\n  /** Enable streaming (not yet supported by RLM) */\n  stream?: boolean;\n\n  // Per-request RLM overrides (Paper Algorithm 1)\n  /** Override max iterations for this request */\n  maxIterations?: number;\n  /** Override max recursion depth for this request */\n  maxDepth?: number;\n  /** Override root model for this request */\n  rootModel?: string;\n  /** Override subcall model for this request */\n  subcallModel?: string;\n  /** Enable trajectory logging for this request */\n  logTrajectories?: boolean;\n  /** Enable cost tracking for this request */\n  trackCosts?: boolean;\n\n  // NOTE: Custom REPL tool injection is NOT supported by the upstream RLM library.\n  // See: https://arxiv.org/abs/2512.24601 Section 3.3 - the paper describes the concept\n  // but the current library implementation does not expose this capability.\n}\n\nexport interface RLMStatusResponse {\n  available: boolean;\n  backend: string;\n  environment: string;\n  maxIterations: number;\n  maxDepth: number;\n}\n\nexport interface IPCRequest {\n  id: number;\n  method: \"infer\" | \"status\" | \"shutdown\";\n  params: Record<string, unknown>;\n}\n\nexport interface IPCResponse<T = unknown> {\n  id: number;\n  result?: T;\n  error?: string;\n}\n\nexport interface IPCReadyMessage {\n  ready: boolean;\n  available: boolean;\n}\n\nexport interface GenerateTextParams {\n  prompt?: string;\n  system?: string;\n  messages?: RLMMessage[];\n  model?: string;\n  maxTokens?: number;\n  temperature?: number;\n  topP?: number;\n  stopSequences?: string[];\n  user?: string;\n  stream?: boolean;\n}\n\nexport const DEFAULT_CONFIG: RLMConfig = {\n  backend: \"gemini\",\n  backendKwargs: {},\n  environment: \"local\",\n  maxIterations: 4,\n  maxDepth: 1,\n  verbose: false,\n  pythonPath: \"python\",\n  maxRetries: 3,\n  retryBaseDelay: 1000,\n  retryMaxDelay: 30000,\n};\n\nexport interface RLMMetrics {\n  totalRequests: number;\n  successfulRequests: number;\n  failedRequests: number;\n  stubResponses: number;\n  totalRetries: number;\n  averageLatencyMs: number;\n  p95LatencyMs: number;\n  lastRequestTimestamp: number;\n  lastErrorTimestamp?: number;\n  lastError?: string;\n}\n\nexport type MetricsCallback = (metrics: RLMMetrics) => void;\n\nexport const ENV_VARS = {\n  BACKEND: \"ELIZA_RLM_BACKEND\",\n  ENVIRONMENT: \"ELIZA_RLM_ENV\",\n  MAX_ITERATIONS: \"ELIZA_RLM_MAX_ITERATIONS\",\n  MAX_DEPTH: \"ELIZA_RLM_MAX_DEPTH\",\n  VERBOSE: \"ELIZA_RLM_VERBOSE\",\n  PYTHON_PATH: \"ELIZA_RLM_PYTHON_PATH\",\n  MAX_RETRIES: \"ELIZA_RLM_MAX_RETRIES\",\n  RETRY_BASE_DELAY: \"ELIZA_RLM_RETRY_BASE_DELAY\",\n  RETRY_MAX_DELAY: \"ELIZA_RLM_RETRY_MAX_DELAY\",\n} as const;\n\nexport const VALID_BACKENDS: readonly RLMBackend[] = [\n  \"openai\",\n  \"anthropic\",\n  \"gemini\",\n  \"groq\",\n  \"openrouter\",\n];\nexport const VALID_ENVIRONMENTS: readonly RLMEnvironment[] = [\"local\", \"docker\", \"modal\", \"prime\"];\n\nexport class RLMConfigError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"RLMConfigError\";\n  }\n}\n\n/** Validate config. Returns errors array, or throws if strict=true. */\nexport function validateConfig(config: Partial<RLMConfig>, strict = false): string[] {\n  const errors: string[] = [];\n\n  if (config.backend !== undefined && !VALID_BACKENDS.includes(config.backend)) {\n    errors.push(`Invalid backend '${config.backend}'. Valid options: ${VALID_BACKENDS.join(\", \")}`);\n  }\n\n  if (config.environment !== undefined && !VALID_ENVIRONMENTS.includes(config.environment)) {\n    errors.push(\n      `Invalid environment '${config.environment}'. Valid options: ${VALID_ENVIRONMENTS.join(\", \")}`,\n    );\n  }\n\n  if (config.maxIterations !== undefined && config.maxIterations < 1) {\n    errors.push(\"maxIterations must be >= 1\");\n  }\n\n  if (config.maxDepth !== undefined && config.maxDepth < 1) {\n    errors.push(\"maxDepth must be >= 1\");\n  }\n\n  if (config.maxRetries !== undefined && config.maxRetries < 0) {\n    errors.push(\"maxRetries must be >= 0\");\n  }\n\n  if (config.retryBaseDelay !== undefined && config.retryBaseDelay < 0) {\n    errors.push(\"retryBaseDelay must be >= 0\");\n  }\n\n  if (\n    config.retryBaseDelay !== undefined &&\n    config.retryMaxDelay !== undefined &&\n    config.retryMaxDelay < config.retryBaseDelay\n  ) {\n    errors.push(\"retryMaxDelay must be >= retryBaseDelay\");\n  }\n\n  if (strict && errors.length > 0) {\n    throw new RLMConfigError(errors.join(\"; \"));\n  }\n\n  return errors;\n}\n"],"mappings":"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","names":["env","logger"]}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@elizaos/plugin-rlm",
+  "version": "2.0.0-alpha.3",
+  "description": "RLM (Recursive Language Model) plugin for elizaOS - enables processing of arbitrarily long contexts",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "bunx @biomejs/biome check --write --unsafe .",
+    "lint:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "lint:check": "bunx @biomejs/biome check .",
+    "format": "bunx @biomejs/biome format --write .",
+    "format:check": "bunx @biomejs/biome format ."
+  },
+  "keywords": [
+    "elizaos",
+    "plugin",
+    "rlm",
+    "recursive-language-model",
+    "ai",
+    "agent",
+    "long-context"
+  ],
+  "author": "elizaOS Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elizaos/eliza.git",
+    "directory": "plugins/plugin-rlm/typescript"
+  },
+  "dependencies": {
+    "@elizaos/core": "2.0.0-alpha.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@elizaos/core": "2.0.0-alpha.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "milaidy": {
+    "platforms": [
+      "node"
+    ],
+    "runtime": "node",
+    "platformDetails": {
+      "node": "ESM build available via exports.import"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}