open-agents-ai 0.187.154 → 0.187.156

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,28 @@ 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 os8 = await import("node:os");
+          const globalFile = path5.join(os8.homedir(), ".open-agents", "error-patterns.json");
+          const localFile = path5.join(process.cwd(), ".oa", "error-patterns.json");
+          for (const patternsFile of [globalFile, localFile]) {
+            try {
+              if (fs4.existsSync(patternsFile)) {
+                const saved = JSON.parse(fs4.readFileSync(patternsFile, "utf8"));
+                for (const [sig, pattern] of Object.entries(saved)) {
+                  const existing = this._errorPatterns.get(sig);
+                  if (!existing || (pattern.count ?? 0) > (existing.count ?? 0)) {
+                    this._errorPatterns.set(sig, pattern);
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
         this._pauseResolve = null;
         this.pendingUserMessages.length = 0;
         this._taskState = {
@@ -265803,6 +265838,14 @@ 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(",");
@@ -265967,6 +266010,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) {
@@ -266640,6 +266735,37 @@ 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 os8 = await import("node:os");
+            const globalFile = path5.join(os8.homedir(), ".open-agents", "error-patterns.json");
+            const localFile = path5.join(process.cwd(), ".oa", "error-patterns.json");
+            for (const targetFile of [globalFile, localFile]) {
+              try {
+                const dir = path5.dirname(targetFile);
+                fs4.mkdirSync(dir, { recursive: true });
+                let existing = {};
+                try {
+                  existing = JSON.parse(fs4.readFileSync(targetFile, "utf8"));
+                } catch {
+                }
+                for (const [sig, pattern] of this._errorPatterns) {
+                  const prev = existing[sig];
+                  existing[sig] = {
+                    ...pattern,
+                    count: Math.max(prev?.count ?? 0, pattern.count),
+                    firstSeen: prev?.firstSeen ?? pattern.lastSeen
+                  };
+                }
+                fs4.writeFileSync(targetFile, JSON.stringify(existing, null, 2));
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
         try {
           const extractPaths = (entries, toolNames) => {
             return [...new Set(entries.filter((tc) => toolNames.includes(tc.name)).map((tc) => {

package/package.json

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