open-agents-ai 0.31.3 → 0.31.4

package/dist/index.js

@@ -10990,6 +10990,7 @@ Rules:
       _pauseResolve = null;
       _sudoPassword = null;
       _sudoResolve = null;
+      _pendingCompaction = null;
       constructor(backend, options) {
         this.backend = backend;
         this.options = {
@@ -11099,6 +11100,23 @@ Rules:
       get isPaused() {
         return this._paused;
       }
+      /**
+       * Request manual context compaction at the next turn boundary.
+       * The strategy controls how aggressively context is compressed:
+       * - "default"    — standard progressive summarization
+       * - "aggressive" — maximum compression, keep only decisions + errors
+       * - "decisions"  — extract action→outcome pairs, discard exploration
+       * - "errors"     — preserve error context, compress successes
+       * - "summary"    — high-level paragraph, minimal detail
+       */
+      requestCompaction(strategy = "default") {
+        this._pendingCompaction = strategy;
+        this.emit({
+          type: "compaction",
+          content: `Manual compaction requested (strategy: ${strategy})`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       /**
        * If paused, block until resume() or abort() is called.
        * Returns true if the loop should continue, false if aborted while paused.
@@ -11246,7 +11264,14 @@ Integrate this guidance into your current approach. Continue working on the task
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          const compacted = this.compactMessages(messages);
+          let compacted;
+          if (this._pendingCompaction) {
+            const strategy = this._pendingCompaction;
+            this._pendingCompaction = null;
+            compacted = this.compactMessages(messages, strategy, true);
+          } else {
+            compacted = this.compactMessages(messages);
+          }
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -11499,7 +11524,14 @@ Integrate this guidance into your current approach. Continue working on the task
               }
               this.emit({ type: "user_interrupt", content: userMsg.replace(/\[IMAGE_BASE64:[^\]]+\]/, "[image]").slice(0, 200), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
             }
-            const compactedMsgs = this.compactMessages(messages);
+            let compactedMsgs;
+            if (this._pendingCompaction) {
+              const strategy = this._pendingCompaction;
+              this._pendingCompaction = null;
+              compactedMsgs = this.compactMessages(messages, strategy, true);
+            } else {
+              compactedMsgs = this.compactMessages(messages);
+            }
             const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
             let response;
             try {
@@ -11683,7 +11715,7 @@ ${tail}`;
       // -------------------------------------------------------------------------
       // Context compaction
       // -------------------------------------------------------------------------
-      compactMessages(messages) {
+      compactMessages(messages, strategy = "default", force = false) {
         if (messages.length < 3)
           return messages;
         const totalChars = messages.reduce((sum, m) => {
@@ -11696,10 +11728,15 @@ ${tail}`;
         }, 0);
         const estimatedTokens = totalChars / 4;
         const limits = this.contextLimits();
-        if (estimatedTokens < limits.compactionThreshold) {
+        if (!force && estimatedTokens < limits.compactionThreshold) {
           return messages;
         }
-        const keepRecent = limits.keepRecent;
+        if (force && messages.length < 5)
+          return messages;
+        let keepRecent = limits.keepRecent;
+        if (strategy === "aggressive" || strategy === "summary") {
+          keepRecent = Math.max(2, Math.floor(keepRecent / 2));
+        }
         const head = messages.slice(0, 2);
         if (messages.length <= 2 + keepRecent)
           return messages;
@@ -11728,16 +11765,35 @@ ${tail}`;
             nonCompactionMiddle.push(msg);
           }
         }
-        const newSummary = this.summarizeCompactedMessages(nonCompactionMiddle);
+        const maskedMiddle = this.maskOldObservations(nonCompactionMiddle);
+        let newSummary;
+        switch (strategy) {
+          case "aggressive":
+            newSummary = this.summarizeAggressive(maskedMiddle);
+            break;
+          case "decisions":
+            newSummary = this.summarizeDecisions(maskedMiddle);
+            break;
+          case "errors":
+            newSummary = this.summarizeErrors(maskedMiddle);
+            break;
+          case "summary":
+            newSummary = this.summarizeHighLevel(maskedMiddle);
+            break;
+          default:
+            newSummary = this.summarizeCompactedMessages(maskedMiddle);
+        }
         const combinedSummary = previousSummary ? this.progressiveSummarize(previousSummary, newSummary) : newSummary;
+        const strategyLabel = strategy !== "default" ? ` (${strategy})` : "";
+        const forceLabel = force ? " [manual]" : "";
         this.emit({
           type: "compaction",
-          content: `Compacted ${middle.length} messages${previousSummary ? " (progressive)" : ""}`,
+          content: `Compacted ${middle.length} messages${strategyLabel}${forceLabel}${previousSummary ? " (progressive)" : ""}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         const compactionMsg = {
           role: "system",
-          content: `[Context compacted \u2014 summary of earlier work]
+          content: `[Context compacted${strategyLabel} \u2014 summary of earlier work]
 
 ${combinedSummary}
 
@@ -11803,6 +11859,56 @@ ${newerSummary}` : newerSummary;
         }
         return condensed.join("\n");
       }
+      /**
+       * Observation masking pre-pass: replace verbose tool outputs with compact
+       * placeholders. Errors and short outputs (<500 chars) are kept verbatim.
+       * Inspired by OpenHands' ObservationMaskingCondenser — zero LLM cost.
+       */
+      maskOldObservations(messages) {
+        const toolCallNames = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallNames.set(tc.id, tc.function.name);
+            }
+          }
+        }
+        return messages.map((msg) => {
+          if (msg.role !== "tool" || typeof msg.content !== "string")
+            return msg;
+          const content = msg.content;
+          if (content.startsWith("Error:") || /^(FAIL|ERR!|TypeError|SyntaxError)/i.test(content))
+            return msg;
+          if (content.length < 500)
+            return msg;
+          const toolName = msg.tool_call_id ? toolCallNames.get(msg.tool_call_id) : void 0;
+          const lines = content.split("\n").length;
+          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 "web_fetch":
+              return { ...msg, content: `[web page content: ${content.length} chars \u2014 omitted for compaction]` };
+            case "web_search":
+              return { ...msg, content: `[search results: ${lines} results \u2014 omitted for compaction]` };
+            case "shell":
+            case "background_run":
+              if (/PASS|FAIL|error|warning/i.test(content))
+                return msg;
+              return { ...msg, content: `[command output: ${lines} lines, ${content.length} chars \u2014 omitted for compaction]` };
+            default:
+              if (content.length > 2e3) {
+                return { ...msg, content: `[${toolName ?? "tool"} output: ${content.length} chars \u2014 omitted for compaction]` };
+              }
+              return msg;
+          }
+        });
+      }
       /**
        * Extract a rich structured summary from compacted messages, preserving:
        * - Assistant analysis/reasoning text
@@ -11970,6 +12076,253 @@ ${newerSummary}` : newerSummary;
         return parts.join("\n");
       }
       // -------------------------------------------------------------------------
+      // Strategy-specific summarizers for manual /compact command
+      // -------------------------------------------------------------------------
+      /**
+       * Aggressive compaction: extract only key decisions and errors.
+       * Discards exploration, file reads, and search results entirely.
+       * Keeps: what files were changed, what errors occurred, what approach was chosen.
+       */
+      summarizeAggressive(messages) {
+        const decisions = [];
+        const errors = [];
+        const filesChanged = /* @__PURE__ */ new Map();
+        let toolCallCount = 0;
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallCount++;
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+              const name = tc.function.name;
+              if (name === "file_edit" || name === "file_write" || name === "batch_edit") {
+                const path = String(args.path || "");
+                if (path)
+                  filesChanged.set(path, name === "file_write" ? "created/rewritten" : "edited");
+              }
+            }
+          }
+          if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim().length > 30) {
+            const text = msg.content.trim();
+            const decisionPatterns = /(?:I (?:will|need to|should|decided|chose|'ll)|Let me|The (?:fix|solution|approach|issue))[^.!?\n]{10,120}[.!?]/gi;
+            const matches = text.match(decisionPatterns);
+            if (matches) {
+              for (const m of matches.slice(0, 2))
+                decisions.push(m.trim());
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string") {
+            const tc = msg.tool_call_id ? toolCallMap.get(msg.tool_call_id) : void 0;
+            if (msg.content.startsWith("Error:") || /FAIL|ERR!/i.test(msg.content)) {
+              const ctx = tc ? `${tc.name}` : "tool";
+              errors.push(`${ctx}: ${msg.content.split("\n")[0]?.slice(0, 150)}`);
+            }
+          }
+        }
+        const parts = [];
+        parts.push(`## Aggressive Compact (${toolCallCount} tool calls compressed)
+`);
+        if (filesChanged.size > 0) {
+          parts.push("### Files Modified");
+          for (const [path, action] of filesChanged)
+            parts.push(`- \`${path}\` (${action})`);
+          parts.push("");
+        }
+        if (decisions.length > 0) {
+          parts.push("### Key Decisions");
+          for (const d of decisions.slice(0, 5))
+            parts.push(`- ${d}`);
+          parts.push("");
+        }
+        if (errors.length > 0) {
+          parts.push("### Errors (avoid repeating)");
+          for (const e of errors.slice(0, 5))
+            parts.push(`- ${e}`);
+        }
+        return parts.join("\n");
+      }
+      /**
+       * Decisions compaction: extract action→outcome pairs only.
+       * Each tool call becomes a single "did X → got Y" line.
+       */
+      summarizeDecisions(messages) {
+        const actionOutcomes = [];
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string" && msg.tool_call_id) {
+            const tc = toolCallMap.get(msg.tool_call_id);
+            if (!tc)
+              continue;
+            const content = msg.content;
+            let action;
+            let outcome;
+            switch (tc.name) {
+              case "file_read":
+                action = `Read \`${tc.args.path}\``;
+                outcome = `${content.split("\n").length} lines`;
+                break;
+              case "file_write":
+                action = `Wrote \`${tc.args.path}\``;
+                outcome = content.startsWith("Error:") ? content.slice(0, 100) : "success";
+                break;
+              case "file_edit":
+                action = `Edited \`${tc.args.path}\``;
+                outcome = content.startsWith("Error:") ? content.slice(0, 100) : "applied";
+                break;
+              case "shell":
+              case "background_run":
+                action = `Ran \`${String(tc.args.command || "").slice(0, 60)}\``;
+                outcome = content.startsWith("Error:") ? "failed" : /PASS|success/i.test(content) ? "passed" : "completed";
+                break;
+              case "grep_search":
+                action = `Searched "${tc.args.pattern}"`;
+                outcome = `${(content.match(/\n/g) || []).length} matches`;
+                break;
+              default:
+                action = tc.name;
+                outcome = content.startsWith("Error:") ? "failed" : "ok";
+            }
+            actionOutcomes.push(`${action} \u2192 ${outcome}`);
+          }
+        }
+        const parts = [];
+        parts.push(`## Decision Log (${actionOutcomes.length} actions)
+`);
+        for (const ao of actionOutcomes)
+          parts.push(`- ${ao}`);
+        return parts.join("\n");
+      }
+      /**
+       * Error-preserving compaction: keep full error context for failure avoidance,
+       * aggressively compress successful operations to single lines.
+       */
+      summarizeErrors(messages) {
+        const errors = [];
+        const successes = [];
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string" && msg.tool_call_id) {
+            const tc = toolCallMap.get(msg.tool_call_id);
+            if (!tc)
+              continue;
+            const content = msg.content;
+            const isError = content.startsWith("Error:") || /FAIL|ERR!|error:|TypeError|SyntaxError/i.test(content);
+            const action = tc.name === "shell" ? `\`${String(tc.args.command || "").slice(0, 80)}\`` : `${tc.name}(${String(tc.args.path || tc.args.pattern || "").slice(0, 60)})`;
+            if (isError) {
+              errors.push({
+                context: action,
+                error: content.slice(0, 300)
+              });
+            } else {
+              successes.push(`${action} \u2192 ok`);
+            }
+          }
+        }
+        const parts = [];
+        parts.push(`## Error-Focused Compact
+`);
+        if (errors.length > 0) {
+          parts.push("### Errors & Failures (preserve to avoid repeating)");
+          for (const { context, error } of errors.slice(0, 8)) {
+            parts.push(`- **${context}**:`);
+            parts.push(`  \`\`\`
+  ${error}
+  \`\`\``);
+          }
+          parts.push("");
+        }
+        if (successes.length > 0) {
+          parts.push(`### Successful Operations (${successes.length} total)`);
+          for (const s of successes.slice(0, 10))
+            parts.push(`- ${s}`);
+          if (successes.length > 10)
+            parts.push(`- ... and ${successes.length - 10} more`);
+        }
+        return parts.join("\n");
+      }
+      /**
+       * High-level summary: paragraph-form description of what was accomplished.
+       * Minimal detail, maximum compression — good for very long sessions.
+       */
+      summarizeHighLevel(messages) {
+        const filesModified = /* @__PURE__ */ new Set();
+        const filesRead = /* @__PURE__ */ new Set();
+        let shellCount = 0;
+        let toolCallCount = 0;
+        let lastAssistantText = "";
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallCount++;
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              const name = tc.function.name;
+              if (name === "file_edit" || name === "file_write" || name === "batch_edit") {
+                filesModified.add(String(args.path || ""));
+              } else if (name === "file_read") {
+                filesRead.add(String(args.path || ""));
+              } else if (name === "shell" || name === "background_run") {
+                shellCount++;
+              }
+            }
+          }
+          if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim().length > 20) {
+            lastAssistantText = msg.content.trim();
+          }
+        }
+        const modList = Array.from(filesModified).filter(Boolean);
+        const readList = Array.from(filesRead).filter(Boolean);
+        const parts = [];
+        parts.push(`## Session Summary (${toolCallCount} tool calls)
+`);
+        parts.push(`Modified ${modList.length} file(s), read ${readList.length} file(s), ran ${shellCount} command(s).
+`);
+        if (modList.length > 0) {
+          parts.push(`Files changed: ${modList.slice(0, 8).map((f) => `\`${f}\``).join(", ")}${modList.length > 8 ? ` +${modList.length - 8} more` : ""}`);
+        }
+        if (lastAssistantText) {
+          parts.push(`
+Last analysis: ${lastAssistantText.slice(0, 300)}${lastAssistantText.length > 300 ? "..." : ""}`);
+        }
+        return parts.join("\n");
+      }
+      // -------------------------------------------------------------------------
       // Tool definition builder
       // -------------------------------------------------------------------------
       buildToolDefinitions() {
@@ -14088,6 +14441,8 @@ function renderSlashHelp() {
     ["/stats", "Show session dashboard (metrics, tool usage, task history)"],
     ["/stop", "Stop current task and save progress (alias: /pause)"],
     ["/resume", "Resume a previously stopped task"],
+    ["/compact", "Force context compaction now (default strategy)"],
+    ["/compact <strategy>", "Compact with strategy: aggressive, decisions, errors, summary"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
@@ -14457,6 +14812,7 @@ var init_render = __esm({
       "/verbose",
       "/dream",
       "/bruteforce",
+      "/compact",
       "/tools",
       "/skills",
       "/clear",
@@ -16578,6 +16934,26 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "compact":
+    case "gc": {
+      if (!ctx.hasActiveTask?.()) {
+        renderWarning("No active task to compact. Context compaction requires a running task.");
+        return "handled";
+      }
+      const validStrategies = ["default", "aggressive", "decisions", "errors", "summary"];
+      const strategy = arg && validStrategies.includes(arg) ? arg : "default";
+      if (arg && !validStrategies.includes(arg)) {
+        renderWarning(`Unknown strategy "${arg}". Valid: ${validStrategies.join(", ")}`);
+        return "handled";
+      }
+      const ok = ctx.requestCompaction?.(strategy) ?? false;
+      if (ok) {
+        renderInfo(`Compaction requested (strategy: ${c2.bold(strategy)}). Will apply at next turn boundary.`);
+      } else {
+        renderWarning("Could not request compaction.");
+      }
+      return "handled";
+    }
     default: {
       const skills = discoverSkills(ctx.repoRoot);
       const skill = skills.find((s) => s.name === cmd || s.name === cmd.replace(/_/g, "-"));
@@ -21610,7 +21986,9 @@ async function startInteractive(config, repoPath) {
     "/skills",
     "/pause",
     "/stop",
-    "/resume"
+    "/resume",
+    "/compact",
+    "/gc"
   ];
   const discoveredSkillNames = discoverSkills(repoRoot).map((s) => `/${s.name}`);
   const allCompletions = [.../* @__PURE__ */ new Set([...BUILTIN_COMMANDS, ...discoveredSkillNames])].sort();
@@ -21901,6 +22279,12 @@ async function startInteractive(config, repoPath) {
       statusBar.setCapabilities(caps);
     },
     hasActiveTask: () => activeTask !== null,
+    requestCompaction(strategy) {
+      if (!activeTask)
+        return false;
+      activeTask.runner.requestCompaction(strategy);
+      return true;
+    },
     abortTask() {
       if (!activeTask)
         return false;

package/package.json

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