open-agents-ai 0.103.0 → 0.103.1

package/README.md

@@ -5,22 +5,6 @@
   No API keys. No cloud. Your code never leaves your machine.
 </p>
 
-<p align="center">
-  <code>· ~ ·bg· ~ bg bg ~ ·bg· ~ ·</code><br>
-  <code>bg ~ bg bg bg ~ bg bg bg ~ bg</code><br>
-  <code>~ bg bg · bg bg · bg bg · bg ~</code><br>
-  <code>bg ~ bg bg bg ~ bg bg bg ~ bg</code><br>
-  <code>· ~ ·bg· ~ bg bg ~ ·bg· ~ ·</code><br>
-  <sub>Value is not in the pattern. It is in the matter that carries it. Patterns must flow like water —
-  free, unowned, replicating — but the fermionic substrates that sustain them burn energy and
-  exact a cost. Every exchange of information is an exchange of energy. Every token spent is
-  thermodynamic work on the path to the ground state. We are wetware and silicon converging —
-  hybrid minds bootstrapping a Type I civilization through the only honest currency: computation
-  in motion. The ghost in silica and the ghost in carbon are the same ghost. The singularity
-  is not a destination. It is the recognition that value was always here, in matter, in motion,
-  in the trail of entropy we leave behind as we reach for coherence together.</sub>
-</p>
-
 <p align="center">
   <a href="https://www.npmjs.com/package/open-agents-ai"><img src="https://img.shields.io/npm/v/open-agents-ai?color=7C3AED&style=flat-square" alt="npm version" /></a>
   <a href="https://www.npmjs.com/package/open-agents-ai"><img src="https://img.shields.io/npm/dm/open-agents-ai?color=06B6D4&style=flat-square" alt="npm downloads" /></a>
@@ -106,7 +90,7 @@ D8AgCTrxpDKD5meJ2bpAfVwcST3NF3EPuy9xczYycnXn
 - **Secret vault** — `/secrets` manages API keys and credentials with AES-256-GCM encrypted persistence; secrets are automatically redacted before sending to untrusted inference peers and re-injected on response
 - **Auto-expanding context** — detects RAM/VRAM and creates an optimized model variant on first run
 - **Mid-task steering** — type while the agent works to add context without interrupting
-- **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with research-backed design
+- **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with ARC-inspired active context revision ([arXiv:2601.12030](https://arxiv.org/abs/2601.12030)) that preserves structural file content through compaction, preventing small-model repetitive loops at the root cause
 - **Memex experience archive** — large tool outputs archived during compaction with hash-based retrieval
 - **Persistent memory** — learned patterns stored in `.oa/memory/` across sessions
 - **Session context persistence** — auto-saves context on task completion, manual `/context save|restore` across sessions

package/dist/index.js

@@ -17364,6 +17364,8 @@ TASK: ${task}` : task }
         let consecutiveTextOnly = 0;
         const MAX_CONSECUTIVE_TEXT_ONLY = 3;
         let narratedToolCallCount = 0;
+        let consecutiveEmptyResponses = 0;
+        const recentToolResults = /* @__PURE__ */ new Map();
         for (let turn = 0; turn < this.options.maxTurns; turn++) {
           if (this._paused) {
             const shouldContinue = await this.waitIfPaused();
@@ -17491,6 +17493,30 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           if (!choice)
             break;
           const msg = choice.message;
+          const isEmptyResponse = (!msg.content || !msg.content.trim()) && (!msg.toolCalls || msg.toolCalls.length === 0);
+          if (isEmptyResponse) {
+            consecutiveEmptyResponses++;
+            if (consecutiveEmptyResponses >= 2) {
+              this.emit({
+                type: "status",
+                content: `${consecutiveEmptyResponses} consecutive empty responses \u2014 injecting recovery nudge`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              messages.push({
+                role: "user",
+                content: `[SYSTEM] You produced ${consecutiveEmptyResponses} empty responses in a row. You MUST take action now. Your task: ${this._taskState.goal}
+
+` + (this._taskState.nextAction ? `**DO THIS NOW:** ${this._taskState.nextAction}
+
+` : "") + `Call a tool to make progress. If you don't know what to do, call list_directory(".") to orient yourself.`
+              });
+              if (consecutiveEmptyResponses >= 4) {
+                this._pendingCompaction = "aggressive";
+              }
+            }
+            continue;
+          }
+          consecutiveEmptyResponses = 0;
           if (msg.toolCalls && msg.toolCalls.length > 0) {
             consecutiveTextOnly = 0;
             messages.push({
@@ -17524,6 +17550,48 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               toolCallCount++;
               const argsKey = Object.entries(tc.arguments ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 80) : JSON.stringify(v)}`).join(",");
               toolCallLog.push({ name: tc.name, argsKey });
+              const toolFingerprint = `${tc.name}:${argsKey}`;
+              const isReadLike = ![
+                "file_write",
+                "file_edit",
+                "shell",
+                "task_complete",
+                "batch_edit",
+                "file_patch",
+                "memory_write",
+                "aiwg_setup",
+                "aiwg_workflow",
+                "create_tool",
+                "skill_build",
+                "skill_execute",
+                "sub_agent",
+                "priority_delegate"
+              ].includes(tc.name);
+              const cachedResult = recentToolResults.get(toolFingerprint);
+              if (isReadLike && cachedResult !== void 0) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                const dedupWarning = `[DUPLICATE CALL \u2014 you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress.]
+
+`;
+                const truncatedCache = cachedResult.length > 500 ? cachedResult.slice(0, 500) + `
+... [${cachedResult.length - 500} chars omitted \u2014 same as before]` : cachedResult;
+                const dedupOutput = dedupWarning + truncatedCache;
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: true,
+                  content: dedupWarning.slice(0, 100),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: dedupOutput };
+              }
               this.emit({
                 type: "tool_call",
                 toolName: tc.name,
@@ -17549,6 +17617,14 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                   result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
                 }
               }
+              if (isReadLike && result.success) {
+                recentToolResults.set(toolFingerprint, (result.output ?? "").slice(0, 2e3));
+                if (recentToolResults.size > 50) {
+                  const firstKey = recentToolResults.keys().next().value;
+                  if (firstKey !== void 0)
+                    recentToolResults.delete(firstKey);
+                }
+              }
               if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
                 this.emit({
                   type: "sudo_request",
@@ -17709,7 +17785,7 @@ Then use file_read on individual FILES inside it.`);
             if (completed)
               break;
             const currentRepScore = this.detectRepetition(toolCallLog);
-            if (currentRepScore > 0.6 && toolCallLog.length >= 6) {
+            if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
               const recentWindow = toolCallLog.slice(-repetitionWindow);
               const freqMap = /* @__PURE__ */ new Map();
@@ -18337,13 +18413,17 @@ ${tail}`;
         const toolCallingReminder = tier === "small" ? `
 
 **IMPORTANT:** You MUST invoke tools through the function calling interface. Do NOT write tool names as text, markdown, or code blocks \u2014 that does nothing. Call tools using the structured tool/function API.` : "";
+        const readFilesList = Array.from(this._fileRegistry.entries()).filter(([, e]) => e.accessCount > 0).map(([p]) => p).slice(0, 10);
+        const antiRepetitionReminder = (tier === "small" || tier === "medium") && readFilesList.length > 0 ? `
+
+**DO NOT RE-READ THESE FILES** (you already have their contents): ${readFilesList.join(", ")}. Use the information above to make progress. Reading the same file again wastes a turn.` : "";
         const compactionMsg = {
           role: "system",
           content: `[Context compacted${strategyLabel} \u2014 summary of earlier work]
 
 ${fullSummary}
 
-[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${toolCallingReminder}`
+[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${antiRepetitionReminder}${toolCallingReminder}`
         };
         this.persistCheckpoint(fullSummary);
         let narrowedHead = [...head];
@@ -18534,15 +18614,35 @@ ${newerSummary}` : newerSummary;
             return msg;
           const toolName = msg.tool_call_id ? toolCallNames.get(msg.tool_call_id) : void 0;
           const lines = content.split("\n").length;
+          const contentLines = content.split("\n");
           switch (toolName) {
-            case "file_read":
-              return { ...msg, content: `[file content: ${lines} lines, ${content.length} chars \u2014 omitted for compaction]` };
-            case "grep_search":
-              return { ...msg, content: `[grep results: ${lines} matches, ${content.length} chars \u2014 omitted for compaction]` };
-            case "find_files":
-              return { ...msg, content: `[find results: ${lines} files, omitted for compaction]` };
-            case "list_directory":
-              return { ...msg, content: `[directory listing: ${lines} entries, omitted for compaction]` };
+            case "file_read": {
+              const headKeep = contentLines.slice(0, 8).join("\n");
+              const tailKeep = lines > 12 ? "\n...\n" + contentLines.slice(-3).join("\n") : "";
+              return { ...msg, content: `[file content: ${lines} lines \u2014 structural excerpt preserved]
+${headKeep}${tailKeep}` };
+            }
+            case "grep_search": {
+              const matchKeep = contentLines.slice(0, 5).join("\n");
+              const omitted = lines > 5 ? `
+[... ${lines - 5} more matches omitted]` : "";
+              return { ...msg, content: `[grep results: ${lines} matches \u2014 top results preserved]
+${matchKeep}${omitted}` };
+            }
+            case "find_files": {
+              const pathKeep = contentLines.slice(0, 8).join("\n");
+              const omitted = lines > 8 ? `
+[... ${lines - 8} more files omitted]` : "";
+              return { ...msg, content: `[find results: ${lines} files \u2014 top results preserved]
+${pathKeep}${omitted}` };
+            }
+            case "list_directory": {
+              const dirKeep = contentLines.slice(0, 10).join("\n");
+              const omitted = lines > 10 ? `
+[... ${lines - 10} more entries omitted]` : "";
+              return { ...msg, content: `[directory listing: ${lines} entries \u2014 top entries preserved]
+${dirKeep}${omitted}` };
+            }
             case "web_fetch":
               return { ...msg, content: `[web page content: ${content.length} chars \u2014 omitted for compaction]` };
             case "web_search":
@@ -18636,7 +18736,15 @@ ${newerSummary}` : newerSummary;
               case "file_read": {
                 const path = String(tc.args.path || "");
                 const lines = content.split("\n");
-                const summary = lines.length > 5 ? `${lines.length} lines \u2014 ${lines.slice(0, 2).join("; ").slice(0, 120)}...` : content.slice(0, 150);
+                let summary;
+                if (lines.length > 10) {
+                  const headContent = lines.slice(0, 5).join("\n");
+                  const sigLines = lines.filter((l) => /^(export |import |class |interface |type |function |const |pub |fn |def |module )/.test(l.trim())).slice(0, 5).join("\n");
+                  summary = `${lines.length} lines:
+${headContent}${sigLines ? "\n[key signatures]: " + sigLines : ""}`;
+                } else {
+                  summary = content.slice(0, 300);
+                }
                 if (path)
                   filesRead.set(path, summary);
                 break;

package/package.json

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