open-agents-ai 0.106.0 → 0.107.0

package/dist/index.js

@@ -7561,6 +7561,44 @@ var init_repl = __esm({
       getSubCallCount() {
         return this.subCallCount;
       }
+      /**
+       * Pre-load a large context string into the REPL as the `context` variable.
+       * Used by prompt externalization (RLM paper §2, Principle 1: symbolic handle).
+       * The context is stored as a Python string variable — the model can then
+       * slice, search, and process it via repl_exec without it entering the LLM context.
+       */
+      async loadContext(content) {
+        if (!this.proc || this.proc.killed || this.proc.exitCode !== null) {
+          await this.startProcess();
+        }
+        const tempFile = join18(tmpdir3(), `oa-repl-ctx-${randomBytes2(6).toString("hex")}.txt`);
+        const { writeFileSync: writeFs, unlinkSync: unlinkFs } = await import("node:fs");
+        writeFs(tempFile, content, "utf8");
+        const result = await this.executeCode(`with open(${JSON.stringify(tempFile)}, "r") as _f:
+    context = _f.read()
+import os; os.unlink(${JSON.stringify(tempFile)})
+print(f"Context loaded: {len(context)} chars")`);
+        try {
+          unlinkFs(tempFile);
+        } catch {
+        }
+        return result.success;
+      }
+      /**
+       * Read a variable's value from the REPL environment.
+       * Used by FINAL_VAR to extract the task output (RLM paper §2, Principle 2).
+       */
+      async readVariable(varName) {
+        if (!this.proc || this.proc.killed || this.proc.exitCode !== null)
+          return null;
+        const result = await this.executeCode(`try:
+    print(str(${varName}))
+except NameError:
+    print("__OA_VAR_NOT_FOUND__")`);
+        if (!result.success || result.output.includes("__OA_VAR_NOT_FOUND__"))
+          return null;
+        return result.output.trim();
+      }
       async execute(args) {
         const code = String(args.code ?? "");
         const reset = Boolean(args.reset);
@@ -19313,7 +19351,8 @@ var init_agenticRunner = __esm({
           modelTier: options?.modelTier ?? "large",
           contextWindowSize: options?.contextWindowSize ?? 0,
           personality: options?.personality ?? PERSONALITY_PRESETS.balanced,
-          personalityName: options?.personalityName ?? ""
+          personalityName: options?.personalityName ?? "",
+          finalVarResolver: options?.finalVarResolver ?? void 0
         };
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
@@ -20382,6 +20421,17 @@ ${result.output}`;
                 summary = content;
                 break;
               }
+              const finalVarMatch = content.match(/FINAL_VAR\s*\(\s*["']?(\w+)["']?\s*\)/);
+              if (finalVarMatch && this.options.finalVarResolver) {
+                const varName = finalVarMatch[1];
+                const varValue = await this.options.finalVarResolver(varName);
+                if (varValue !== null) {
+                  completed = true;
+                  summary = varValue;
+                  this.emit({ type: "status", content: `FINAL_VAR(${varName}): resolved ${varValue.length} chars from REPL`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                  break;
+                }
+              }
               if (consecutiveTextOnly >= MAX_CONSECUTIVE_TEXT_ONLY) {
                 this.emit({
                   type: "status",
@@ -50240,6 +50290,12 @@ ${context}` : prompt;
       });
     }
   }
+  const replToolForFinalVar = tools.find((t) => t.name === "repl_exec");
+  if (replToolForFinalVar && "readVariable" in replToolForFinalVar) {
+    runner.options.finalVarResolver = async (varName) => {
+      return replToolForFinalVar.readVariable(varName);
+    };
+  }
   runner.registerTools(tools);
   runner.registerTool({
     name: "memex_retrieve",
@@ -50698,7 +50754,30 @@ ${entry.fullContent}`
 
 ${emotionContext}` : `Working directory: ${repoRoot}`;
   resetNarrationContext();
-  const promise = runner.run(task, systemContext).then((result) => {
+  let effectiveTask = task;
+  const estimatedTaskTokens = Math.ceil(task.length / 4);
+  const externalizeThreshold = contextWindowSize ? Math.floor(contextWindowSize * 0.4) : 3e4;
+  if (estimatedTaskTokens > externalizeThreshold) {
+    const replTool = tools.find((t) => t.name === "repl_exec");
+    if (replTool && "loadContext" in replTool) {
+      replTool.loadContext(task);
+      const prefix = task.slice(0, 500).replace(/\n/g, " ");
+      effectiveTask = `[RLM MODE \u2014 Large input externalized to REPL]
+Your input has been stored as the variable \`context\` in the persistent Python REPL.
+Context length: ${task.length} characters (~${estimatedTaskTokens} tokens)
+Prefix: "${prefix}..."
+
+Use repl_exec to examine and process the context. For example:
+  repl_exec(code="print(context[:1000])")  # see the beginning
+  repl_exec(code="print(len(context))")    # check length
+  repl_exec(code="chunks = context.split('\\n\\n')")  # split into chunks
+
+Use llm_query(prompt, chunk) inside repl_exec to analyze chunks.
+When done, either call task_complete with your answer, or use FINAL_VAR(variable_name) to return a REPL variable as the output.`;
+      contentWrite(() => renderInfo(`RLM: Externalized ${task.length} chars (~${estimatedTaskTokens} tokens) to REPL context variable`));
+    }
+  }
+  const promise = runner.run(effectiveTask, systemContext).then((result) => {
     const tokens = { total: result.totalTokens, estimated: result.estimatedTokens };
     contentWrite(() => {
       if (result.completed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.106.0",
+  "version": "0.107.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",