open-agents-ai 0.187.236 → 0.187.238

package/dist/index.js

@@ -270794,6 +270794,32 @@ ${memoryLines.join("\n")}`
             maxTokens: effectiveMaxTokens,
             timeoutMs: this.options.requestTimeoutMs
           };
+          {
+            const ctxChars = compacted.reduce((s2, m2) => {
+              let c7 = typeof m2.content === "string" ? m2.content.length : 100;
+              if (m2.tool_calls)
+                for (const tc of m2.tool_calls)
+                  c7 += tc.function.arguments?.length ?? 0;
+              return s2 + c7;
+            }, 0);
+            const estTokens = Math.ceil(ctxChars / 4);
+            const limits = this.contextLimits();
+            this.emit({
+              type: "debug_context",
+              content: `Turn ${turn}: ${compacted.length} msgs, ~${estTokens} tokens (threshold: ${limits.compactionThreshold}), headroom: ${limits.compactionThreshold - estTokens}`,
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              contextSnapshot: {
+                messageCount: compacted.length,
+                estimatedTokens: estTokens,
+                compactionThreshold: limits.compactionThreshold,
+                toolCallCount,
+                keepRecent: limits.keepRecent,
+                littlemanOutcomes: this._littlemanToolOutcomes.length,
+                headroom: limits.compactionThreshold - estTokens
+              }
+            });
+          }
           let response;
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
@@ -271575,6 +271601,7 @@ ${sr.result.output}`;
             }
             if (completed)
               break;
+            this.littlemanObserve(messages2, turn);
             const currentRepScore = this.detectRepetition(toolCallLog);
             if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
@@ -271957,7 +271984,7 @@ ${result.output}`;
                     turn,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  output = `[Output externalized — ${result.output.length} chars, ${lineCount} lines]
+                  output = `[${tc.name} succeeded — output externalized: ${result.output.length} chars, ${lineCount} lines]
 Handle: ${handleId}
 Preview: ${preview}...
 Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or  memex_retrieve(id="${handleId}")`;
@@ -272380,7 +272407,7 @@ ${errOutput}`;
 ${result.output}`, "utf-8");
         } catch {
         }
-        return `[Output externalized — ${result.output.length} chars, ${lineCount} lines]
+        return `[${toolName} succeeded — output externalized: ${result.output.length} chars, ${lineCount} lines]
 Handle: ${handleId}
 Preview: ${preview}...
 Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or  memex_retrieve(id="${handleId}")`;
@@ -272882,6 +272909,113 @@ ${newerSummary}`;
 
 ${trimmedNew}`;
       }
+      // -------------------------------------------------------------------------
+      // Littleman Observer — parallel meta-analysis of the main loop
+      // -------------------------------------------------------------------------
+      // Inspired by Hannover's fireCompanionObserver (src/buddy/observer.ts).
+      // Runs after each tool turn to detect when the model has lost track of
+      // what happened and inject corrections before the next inference.
+      //
+      // This is the architectural fix for the "I see both tools have been failing"
+      // regression: instead of only fixing the data the model sees (mask/summary),
+      // we add a second analysis path that catches mismatches in real-time.
+      /** Track recent tool outcomes for the littleman observer */
+      _littlemanToolOutcomes = [];
+      /**
+       * Littleman observer: post-turn meta-analysis.
+       *
+       * Examines the last few messages looking for contradictions between
+       * actual tool outcomes and the model's stated understanding. When it
+       * detects the model claiming failure after success (or vice versa),
+       * it injects a corrective message.
+       *
+       * Also detects repeated actions — when the model re-does something
+       * that already succeeded, the littleman nudges it to move on.
+       */
+      littlemanObserve(messages2, turn) {
+        if (this.options.modelTier === "large")
+          return;
+        const recent = messages2.slice(-6);
+        for (const msg of recent) {
+          if (msg.role === "tool" && typeof msg.content === "string") {
+            const isError2 = msg.content.startsWith("Error:") || /^(FAIL|ERR!|TypeError)/i.test(msg.content);
+            const succeeded = !isError2;
+            const preview = msg.content.slice(0, 80);
+            let toolName = "unknown";
+            if (msg.tool_call_id) {
+              for (const m2 of recent) {
+                if (m2.tool_calls) {
+                  for (const tc of m2.tool_calls) {
+                    if (tc.id === msg.tool_call_id) {
+                      toolName = tc.function.name;
+                    }
+                  }
+                }
+              }
+            }
+            if (!this._littlemanToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName)) {
+              this._littlemanToolOutcomes.push({ turn, tool: toolName, succeeded, preview });
+            }
+          }
+        }
+        while (this._littlemanToolOutcomes.length > 20)
+          this._littlemanToolOutcomes.shift();
+        const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+        if (lastAssistant && typeof lastAssistant.content === "string") {
+          const text = lastAssistant.content.toLowerCase();
+          const claimsFailure = /(?:fail|error|didn't work|not working|unable to|cannot|couldn't|both .* fail|tools? (?:have |has )?been fail)/i.test(text);
+          if (claimsFailure) {
+            const recentOutcomes = this._littlemanToolOutcomes.slice(-4);
+            const successes = recentOutcomes.filter((o2) => o2.succeeded);
+            if (successes.length >= 1) {
+              const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
+              this.pendingUserMessages.push(`[LITTLEMAN] Correction: your recent tools DID succeed. Do not retry them.
+Successful results: ${successList}
+Build on these results instead of retrying. What is your NEXT step toward the goal?`);
+              this.emit({
+                type: "status",
+                content: `Littleman: corrected false failure claim (${successes.length} tools succeeded)`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        }
+        const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
+        for (const tc of lastToolCalls) {
+          const name10 = tc.function.name;
+          let args = {};
+          try {
+            args = JSON.parse(tc.function.arguments);
+          } catch {
+          }
+          const argsKey = name10 === "shell" ? String(args.command ?? "").slice(0, 60) : name10 === "web_fetch" ? String(args.url ?? "").slice(0, 80) : String(args.path ?? args.url ?? args.query ?? "").slice(0, 60);
+          const prior = this._littlemanToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.preview.includes(argsKey.slice(0, 30)) && o2.turn < turn);
+          if (prior) {
+            this.pendingUserMessages.push(`[LITTLEMAN] You already ran ${name10} successfully on turn ${prior.turn} with similar arguments. Result was: ${prior.preview.slice(0, 100)}
+Do NOT re-run it. Use the result you already have and proceed to the next step.`);
+            this.emit({
+              type: "status",
+              content: `Littleman: prevented redundant ${name10} call (succeeded on turn ${prior.turn})`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            break;
+          }
+        }
+        const succCount = this._littlemanToolOutcomes.filter((o2) => o2.succeeded).length;
+        const failCount = this._littlemanToolOutcomes.filter((o2) => !o2.succeeded).length;
+        this.emit({
+          type: "debug_littleman",
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          content: `Littleman: ${this._littlemanToolOutcomes.length} tracked outcomes (${succCount} ok, ${failCount} err)`,
+          littlemanAction: {
+            detection: "none",
+            recentSuccesses: succCount,
+            recentFailures: failCount,
+            intervention: this.pendingUserMessages.length > 0 ? this.pendingUserMessages[this.pendingUserMessages.length - 1]?.slice(0, 120) ?? null : null
+          }
+        });
+      }
       /**
        * Infer what the model should do next from the most recent messages.
        * Analyzes the last few tool calls, errors, and assistant text to produce
@@ -273030,18 +273164,37 @@ ${pathKeep}${omitted}` };
               return { ...msg, content: `[directory listing: ${lines} entries — top entries preserved]
 ${dirKeep}${omitted}` };
             }
-            case "web_fetch":
-              return { ...msg, content: `[web page content: ${content.length} chars — omitted for compaction]` };
-            case "web_search":
-              return { ...msg, content: `[search results: ${lines} results — omitted for compaction]` };
+            case "web_fetch": {
+              const webPreview = contentLines.slice(0, 5).join("\n");
+              const webOmitted = lines > 5 ? `
+[... ${lines - 5} more lines omitted for compaction]` : "";
+              return { ...msg, content: `[web_fetch succeeded: ${content.length} chars, ${lines} lines — preview preserved]
+${webPreview}${webOmitted}` };
+            }
+            case "web_search": {
+              const searchPreview = contentLines.slice(0, 5).join("\n");
+              const searchOmitted = lines > 5 ? `
+[... ${lines - 5} more results omitted]` : "";
+              return { ...msg, content: `[web_search succeeded: ${lines} results — top results preserved]
+${searchPreview}${searchOmitted}` };
+            }
             case "shell":
-            case "background_run":
+            case "background_run": {
               if (/PASS|FAIL|error|warning/i.test(content))
                 return msg;
-              return { ...msg, content: `[command output: ${lines} lines, ${content.length} chars — omitted for compaction]` };
+              const cmdPreview = contentLines.slice(0, 5).join("\n");
+              const cmdOmitted = lines > 5 ? `
+[... ${lines - 5} more lines omitted for compaction]` : "";
+              return { ...msg, content: `[shell succeeded: ${lines} lines, ${content.length} chars — preview preserved]
+${cmdPreview}${cmdOmitted}` };
+            }
             default:
               if (content.length > 2e3) {
-                return { ...msg, content: `[${toolName ?? "tool"} output: ${content.length} chars — omitted for compaction]` };
+                const genPreview = contentLines.slice(0, 3).join("\n");
+                const genOmitted = lines > 3 ? `
+[... ${lines - 3} more lines omitted]` : "";
+                return { ...msg, content: `[${toolName ?? "tool"} succeeded: ${content.length} chars — preview preserved]
+${genPreview}${genOmitted}` };
               }
               return msg;
           }
@@ -273141,19 +273294,45 @@ ${headContent}${sigLines ? "\n[key signatures]: " + sigLines : ""}`;
                 const cmd = String(tc.args.command || "").slice(0, 100);
                 const hasError = content.startsWith("Error:") || /FAIL|ERR!/i.test(content);
                 const hasPass = /PASS|passed|✓|success/i.test(content);
+                const hasMaskedSuccess = /^\[shell succeeded:|^\[.+ succeeded —/.test(content);
                 let outcome;
                 if (hasError) {
                   const errorLines = content.split("\n").filter((l2) => /error|FAIL|✗|×|ERR!/i.test(l2)).slice(0, 3);
                   outcome = errorLines.length > 0 ? errorLines.join("; ").slice(0, 200) : content.slice(0, 200);
                   errors.push(`\`${cmd}\`: ${outcome.slice(0, 150)}`);
-                } else if (hasPass) {
-                  outcome = "passed";
+                } else if (hasPass || hasMaskedSuccess) {
+                  const previewLines = content.split("\n").slice(1, 4).join(" ").trim();
+                  outcome = previewLines ? `succeeded: ${previewLines.slice(0, 120)}` : "succeeded";
                 } else {
                   outcome = content.slice(0, 150);
                 }
                 commandResults.push({ cmd, outcome });
                 break;
               }
+              case "web_fetch": {
+                const url = String(tc.args.url || "").slice(0, 120);
+                if (content.startsWith("Error:")) {
+                  const errMsg = content.slice(0, 200);
+                  errors.push(`web_fetch \`${url}\`: ${errMsg}`);
+                  commandResults.push({ cmd: `web_fetch ${url}`, outcome: errMsg });
+                } else {
+                  const preview = content.split("\n").slice(0, 3).join(" ").trim().slice(0, 150);
+                  commandResults.push({ cmd: `web_fetch ${url}`, outcome: `succeeded: ${preview || `${content.length} chars`}` });
+                }
+                break;
+              }
+              case "web_search": {
+                const query = String(tc.args.query || "").slice(0, 80);
+                if (content.startsWith("Error:")) {
+                  errors.push(`web_search "${query}": ${content.slice(0, 200)}`);
+                  commandResults.push({ cmd: `web_search "${query}"`, outcome: content.slice(0, 200) });
+                } else {
+                  const resultCount = (content.match(/\n/g) || []).length;
+                  const preview = content.split("\n").slice(0, 2).join(" ").trim().slice(0, 100);
+                  commandResults.push({ cmd: `web_search "${query}"`, outcome: `${resultCount} results: ${preview}` });
+                }
+                break;
+              }
               case "grep_search": {
                 const pattern = String(tc.args.pattern || "");
                 const matchCount = (content.match(/\n/g) || []).length;
@@ -328450,6 +328629,26 @@ ${entry.fullContent}`
         break;
       case "complete":
         break;
+      // -- Live observability hooks --
+      case "debug_context":
+        if (config.verbose) {
+          const snap = event.contextSnapshot;
+          if (snap) {
+            contentWrite(() => renderInfo(
+              `\x1B[38;5;243m[ctx] ${snap.messageCount} msgs | ~${snap.estimatedTokens} tok | headroom: ${snap.headroom} | tools: ${snap.toolCallCount} | littleman: ${snap.littlemanOutcomes} tracked\x1B[0m`
+            ));
+          }
+        }
+        break;
+      case "debug_littleman":
+        if (config.verbose && event.littlemanAction) {
+          const lm = event.littlemanAction;
+          const intervention = lm.intervention ? ` | INTERVENTION: ${lm.intervention}` : "";
+          contentWrite(() => renderInfo(
+            `\x1B[38;5;178m[littleman] ${lm.recentSuccesses} ok, ${lm.recentFailures} err${intervention}\x1B[0m`
+          ));
+        }
+        break;
     }
   });
   const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

package/dist/scripts/.env

@@ -0,0 +1,14 @@
+SCRAPE_API_KEY=948a46e9c7b94025aba48cf43f823950
+SCRAPE_BIND=0.0.0.0
+SCRAPE_PORT=8130
+SCRAPE_REQUIRE_AUTH=0
+SCRAPE_MAX_CONCURRENCY=4
+SCRAPE_QUEUE_TIMEOUT_S=0
+SCRAPE_RATE_LIMIT_RPS=60
+SCRAPE_RATE_LIMIT_BURST=180
+SCRAPE_RATE_LIMIT_LOCAL_BYPASS=1
+SCRAPE_RATE_LIMIT_DISABLED=0
+SCRAPE_RATE_LIMIT_WHITELIST=
+SCRAPE_FILE_TTL_S=900
+SCRAPE_FRAME_KEEPALIVE_S=45
+SCRAPE_HEADLESS_DEFAULT=1

package/dist/scripts/.scrape_setup_complete

@@ -0,0 +1 @@
+ok

package/package.json

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