open-agents-ai 0.187.153 → 0.187.155

package/dist/index.js

@@ -264709,6 +264709,19 @@ var init_agenticRunner = __esm({
       // WO-KG-15
       _retrievalContextCache = null;
       // WO-KG-15: cache per-run
+      // ── WO-NC-07: Error pattern learning → pre-action guidance injection ──
+      // Records error patterns (tool + error signature → learned guidance).
+      // When the same tool+context is about to be called again, injects the
+      // learned guidance BEFORE execution to prevent repeating the same mistake.
+      //
+      // Structure: Map<errorSignature, { count, guidance, lastSeen }>
+      // errorSignature = `${toolName}:${errorType}` (e.g. "file_read:ENOENT", "shell:permission_denied")
+      //
+      // Research: Kumaran et al. (2016) — complementary learning systems
+      //           Fast learning from errors → immediate behavioral change
+      _errorPatterns = /* @__PURE__ */ new Map();
+      _errorGuidanceInjected = /* @__PURE__ */ new Set();
+      // prevent duplicate injection per turn
       _loopBlockedTools;
       // Loop intervention: tools removed from schema
       // -- Session Checkpointing (Priority 5) --
@@ -265234,6 +265247,18 @@ Respond with your assessment, then take action.`;
         const toolCallLog = [];
         this.aborted = false;
         this._paused = false;
+        try {
+          const fs4 = await import("node:fs");
+          const path5 = await import("node:path");
+          const patternsFile = path5.join(process.cwd(), ".oa", "error-patterns.json");
+          if (fs4.existsSync(patternsFile)) {
+            const saved = JSON.parse(fs4.readFileSync(patternsFile, "utf8"));
+            for (const [sig, pattern] of Object.entries(saved)) {
+              this._errorPatterns.set(sig, pattern);
+            }
+          }
+        } catch {
+        }
         this._pauseResolve = null;
         this.pendingUserMessages.length = 0;
         this._taskState = {
@@ -265520,8 +265545,19 @@ ${top.map((t2) => `- ${t2.name}: ${t2.desc}`).join("\n")}`
           const turnBudget = turnTier === "small" ? 5 : turnTier === "medium" ? 8 : 0;
           if (turnBudget > 0 && turn > 0 && turn % turnBudget === 0) {
             const repetitionRatio = this.detectRepetition(toolCallLog);
+            const recentToolResults2 = messages2.slice(-16).filter((m2) => m2.role === "tool" && typeof m2.content === "string");
+            const recentErrors = recentToolResults2.filter((m2) => /error|failed|not found|permission denied/i.test(String(m2.content))).length;
+            const errorRatio = recentToolResults2.length > 0 ? recentErrors / recentToolResults2.length : 0;
             const noProgress = this._taskState.completedSteps.length === 0 && turn >= turnBudget;
             const isLooping = repetitionRatio > 0.4;
+            const highArousal = errorRatio > 0.5 || isLooping;
+            if (highArousal && !isLooping && !noProgress) {
+              this.pendingUserMessages.push(`[COGNITIVE STATE: HIGH AROUSAL] Recent error rate is ${Math.round(errorRatio * 100)}%. Your current approach may be hitting a wall. Consider:
+1. Read related files you haven't examined yet
+2. Search for similar patterns in the codebase
+3. Check if your assumptions about the API/framework are correct
+State what you've learned from the errors before trying again.`);
+            }
             if (isLooping || noProgress) {
               const progress = this._taskState.completedSteps.slice(-3).join("; ");
               const failures = this._taskState.failedApproaches.slice(-2).join("; ");
@@ -265792,10 +265828,18 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             const executeSingle = async (tc) => {
               if (this.aborted)
                 return null;
+              if (this._errorPatterns.size > 0) {
+                for (const [sig, pattern] of this._errorPatterns) {
+                  if (pattern.tool === tc.name && pattern.count >= 2 && !this._errorGuidanceInjected.has(sig)) {
+                    this._errorGuidanceInjected.add(sig);
+                    this.pendingUserMessages.push(`[LEARNED FROM EXPERIENCE] ${tc.name} has failed ${pattern.count} times with "${pattern.errorType}" errors. Guidance: ${pattern.guidance}`);
+                  }
+                }
+              }
               const toolStart = performance.now();
               toolCallCount++;
               const argsKey = Object.entries(tc.arguments ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 80) : JSON.stringify(v)}`).join(",");
-              toolCallLog.push({ name: tc.name, argsKey });
+              toolCallLog.push({ name: tc.name, argsKey, turn, timestampMs: Date.now() });
               const budgetRemaining = toolCallBudget.get(tc.name);
               if (budgetRemaining !== void 0) {
                 if (budgetRemaining <= 0) {
@@ -265956,6 +266000,58 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                   }
                 }
               }
+              if (!result.success && result.error) {
+                const errorText = result.error;
+                let errorType = "unknown";
+                if (/not found|ENOENT|no such file/i.test(errorText))
+                  errorType = "not_found";
+                else if (/permission|denied|EACCES/i.test(errorText))
+                  errorType = "permission";
+                else if (/timeout|timed out|ETIMEDOUT/i.test(errorText))
+                  errorType = "timeout";
+                else if (/busy|EBUSY|in use/i.test(errorText))
+                  errorType = "busy";
+                else if (/syntax|parse|invalid/i.test(errorText))
+                  errorType = "syntax";
+                else if (/connect|ECONNREFUSED|network/i.test(errorText))
+                  errorType = "network";
+                const sig = `${tc.name}:${errorType}`;
+                const existing = this._errorPatterns.get(sig);
+                const count = (existing?.count ?? 0) + 1;
+                let guidance = "";
+                switch (errorType) {
+                  case "not_found":
+                    guidance = `File/resource not found. Before retrying: use list_directory or find_files to verify the path exists. Common causes: wrong directory, typo in filename, file was moved/renamed.`;
+                    break;
+                  case "permission":
+                    guidance = `Permission denied. The command may need sudo/elevated privileges. Use shell with sudo, or check file ownership with 'ls -la'.`;
+                    break;
+                  case "timeout":
+                    guidance = `Operation timed out. The target may be unreachable or overloaded. Try: shorter timeout, different endpoint, or verify network connectivity first.`;
+                    break;
+                  case "busy":
+                    guidance = `Resource is busy/locked. Another process may be using it. Check with 'lsof' or 'fuser', or wait and retry.`;
+                    break;
+                  case "syntax":
+                    guidance = `Syntax/parse error. Review the command or input for typos, missing quotes, or incorrect parameter format.`;
+                    break;
+                  case "network":
+                    guidance = `Network error. Check connectivity: ping the target, verify the URL/host is correct, check if a proxy is needed.`;
+                    break;
+                  default:
+                    guidance = `This tool failed previously with a similar error. Review the error message carefully and adjust your approach before retrying.`;
+                }
+                this._errorPatterns.set(sig, { count, guidance, lastSeen: Date.now(), tool: tc.name, errorType });
+                const lastLog = toolCallLog[toolCallLog.length - 1];
+                if (lastLog) {
+                  lastLog.success = false;
+                  lastLog.outputPreview = errorText.slice(0, 100);
+                }
+              } else if (result.success) {
+                const lastLog = toolCallLog[toolCallLog.length - 1];
+                if (lastLog)
+                  lastLog.success = true;
+              }
               if (isReadLike && result.success) {
                 recentToolResults.set(toolFingerprint, (result.output ?? "").slice(0, 2e3));
                 if (recentToolResults.size > 50) {
@@ -266629,6 +266725,118 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
+        if (this._errorPatterns.size > 0) {
+          try {
+            const fs4 = await import("node:fs");
+            const path5 = await import("node:path");
+            const patternsFile = path5.join(process.cwd(), ".oa", "error-patterns.json");
+            fs4.mkdirSync(path5.join(process.cwd(), ".oa"), { recursive: true });
+            let existing = {};
+            try {
+              existing = JSON.parse(fs4.readFileSync(patternsFile, "utf8"));
+            } catch {
+            }
+            for (const [sig, pattern] of this._errorPatterns) {
+              const prev = existing[sig];
+              existing[sig] = {
+                ...pattern,
+                count: (prev?.count ?? 0) + pattern.count,
+                firstSeen: prev?.firstSeen ?? pattern.lastSeen
+              };
+            }
+            fs4.writeFileSync(patternsFile, JSON.stringify(existing, null, 2));
+          } catch {
+          }
+        }
+        try {
+          const extractPaths = (entries, toolNames) => {
+            return [...new Set(entries.filter((tc) => toolNames.includes(tc.name)).map((tc) => {
+              const pathMatch = tc.argsKey.match(/path=([^,]+)/);
+              return pathMatch?.[1] || "";
+            }).filter(Boolean))];
+          };
+          const consolidation = {
+            sessionId: this._sessionId,
+            task: task.slice(0, 500),
+            outcome: completed ? "success" : this.aborted ? "aborted" : "timeout",
+            turns: messages2.filter((m2) => m2.role === "assistant").length,
+            toolsUsed: [...new Set(toolCallLog.map((tc) => tc.name))],
+            filesModified: extractPaths(toolCallLog, ["file_write", "file_edit", "file_patch", "batch_edit"]),
+            filesRead: extractPaths(toolCallLog, ["file_read"]),
+            totalToolCalls: toolCallLog.length,
+            durationMs,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const fs4 = await import("node:fs");
+          const path5 = await import("node:path");
+          const consolidDir = path5.join(process.cwd(), ".oa", "consolidations");
+          fs4.mkdirSync(consolidDir, { recursive: true });
+          fs4.writeFileSync(path5.join(consolidDir, `${this._sessionId}.json`), JSON.stringify(consolidation, null, 2));
+          const provenanceDir = path5.join(process.cwd(), ".oa", "provenance");
+          fs4.mkdirSync(provenanceDir, { recursive: true });
+          const provenanceGraph = {
+            sessionId: this._sessionId,
+            task: task.slice(0, 500),
+            outcome: consolidation.outcome,
+            timestamp: consolidation.timestamp,
+            // Full action trace — every tool call with sequence ordering
+            actions: toolCallLog.map((tc, idx) => ({
+              id: `${this._sessionId}-${idx}`,
+              tool: tc.name,
+              args_fingerprint: tc.argsKey.slice(0, 200),
+              turn: tc.turn,
+              timestamp_ms: tc.timestampMs,
+              // Causal links: which earlier action informed this one?
+              // Heuristic: if this action reads a file that a previous action wrote, they're linked
+              caused_by: toolCallLog.slice(0, idx).filter((prev) => {
+                const prevPath = prev.argsKey.match(/path=([^,]+)/)?.[1];
+                const thisPath = tc.argsKey.match(/path=([^,]+)/)?.[1];
+                return prevPath && thisPath && prevPath === thisPath && ["file_write", "file_edit"].includes(prev.name) && ["file_read", "grep_search"].includes(tc.name);
+              }).map((_, prevIdx) => `${this._sessionId}-${prevIdx}`)
+            })),
+            // File dependency graph: which files were read before being modified?
+            file_provenance: (() => {
+              const readTurns = /* @__PURE__ */ new Map();
+              const writeTurns = /* @__PURE__ */ new Map();
+              for (const tc of toolCallLog) {
+                const filePath = tc.argsKey.match(/path=([^,]+)/)?.[1];
+                if (!filePath)
+                  continue;
+                if (tc.name === "file_read" && !readTurns.has(filePath))
+                  readTurns.set(filePath, tc.turn ?? 0);
+                if (["file_write", "file_edit"].includes(tc.name))
+                  writeTurns.set(filePath, tc.turn ?? 0);
+              }
+              const deps = [];
+              for (const [file, writeTurn] of writeTurns) {
+                const readTurn = readTurns.get(file);
+                if (readTurn !== void 0 && readTurn < writeTurn) {
+                  deps.push({ file, read_turn: readTurn, write_turn: writeTurn });
+                }
+              }
+              return deps;
+            })()
+          };
+          fs4.writeFileSync(path5.join(provenanceDir, `${this._sessionId}.json`), JSON.stringify(provenanceGraph, null, 2));
+          if (completed && this.tools.has("memory_write")) {
+            const memTool = this.tools.get("memory_write");
+            const lessonContent = `Task "${task.slice(0, 100)}" completed successfully. Tools: ${consolidation.toolsUsed.join(", ")}. Files: ${consolidation.filesModified.slice(0, 3).join(", ")}. Duration: ${Math.round(durationMs / 1e3)}s, ${consolidation.turns} turns.`;
+            try {
+              await memTool.execute({
+                topic: "task_lessons",
+                key: this._sessionId,
+                value: lessonContent
+              });
+            } catch {
+            }
+          }
+          this.emit({
+            type: "status",
+            content: `Task consolidation: ${consolidation.outcome}, ${consolidation.toolsUsed.length} tools, ${consolidation.filesModified.length} files modified`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
         this._hookManager.runSessionHook("session_end", this._sessionId);
         try {
           const fs4 = await import("node:fs");

package/package.json

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