open-agents-ai 0.187.479 → 0.187.480

package/dist/index.js

@@ -512229,6 +512229,87 @@ var init_critic = __esm({
   }
 });
 
+// packages/orchestrator/dist/reflection.js
+function categorizeError(errorText) {
+  if (!errorText)
+    return "unknown";
+  for (const { category, re } of CATEGORY_PATTERNS) {
+    if (re.test(errorText))
+      return category;
+  }
+  return "unknown";
+}
+function buildStem(toolName, args) {
+  if (!args || Object.keys(args).length === 0)
+    return toolName;
+  const entries = Object.entries(args).sort(([a2], [b]) => a2.localeCompare(b));
+  const first2 = entries[0];
+  const v = typeof first2[1] === "string" ? first2[1] : JSON.stringify(first2[1]);
+  return `${toolName}:${first2[0]}=${v.slice(0, 60)}`;
+}
+function firstSignalLine(errorText) {
+  if (!errorText)
+    return "";
+  const lines = errorText.split(/\r?\n/);
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    if (line === "Error:" || line === "error:")
+      continue;
+    return line.slice(0, 200);
+  }
+  return errorText.slice(0, 200);
+}
+function synthesizeReflection(input) {
+  const category = categorizeError(input.errorText);
+  const stem = buildStem(input.toolName, input.args);
+  const argPreview = JSON.stringify(input.args ?? {}).slice(0, 120);
+  return {
+    stem,
+    attempted: `${input.toolName}(${argPreview})`,
+    wentWrong: firstSignalLine(input.errorText),
+    hypothesis: HYPOTHESES[category],
+    turn: input.turn,
+    attempts: (input.priorAttempts ?? 0) + 1
+  };
+}
+function renderReflectionMessage(r2) {
+  return [
+    `[REFLECTION — your last attempt of \`${r2.attempted}\` failed (turn ${r2.turn}, ${r2.attempts} attempt${r2.attempts === 1 ? "" : "s"} so far).`,
+    `Last error: "${r2.wentWrong}"`,
+    `Hypothesis: ${r2.hypothesis}`,
+    `VERIFY this hypothesis with a single small command BEFORE retrying the same tool. If you retry without verifying, you will likely fail the same way.]`
+  ].join("\n");
+}
+var CATEGORY_PATTERNS, HYPOTHESES;
+var init_reflection = __esm({
+  "packages/orchestrator/dist/reflection.js"() {
+    "use strict";
+    CATEGORY_PATTERNS = [
+      { category: "permission_denied", re: /\b(permission denied|eacces|access denied|operation not permitted|forbidden)\b/i },
+      { category: "type_or_reference_error", re: /\b(type error|cannot find module|cannot find name|is not (a function|defined|assignable)|undefined reference|unresolved (import|reference)|missing required)\b/i },
+      { category: "connection_refused", re: /\b(connection refused|econnrefused|connection reset|econnreset|host unreachable|getaddrinfo|enotfound)\b/i },
+      { category: "timeout", re: /\b(timeout|timed out|etimedout|deadline exceeded)\b/i },
+      { category: "syntax_error", re: /\b(syntax error|parse error|unexpected token|unexpected end of (input|json)|malformed)\b/i },
+      { category: "not_found", re: /\b(not found|enoent|no such file|cannot find|does not exist|404)\b/i },
+      // Use [1-9]\d* so multi-digit non-zero codes (e.g. "return code 127") match —
+      // the prior [^0] only matched a single character and failed on multi-digit.
+      { category: "nonzero_exit", re: /\b(exit code [1-9]\d*|exit status [1-9]\d*|command failed|exit code: ?[1-9]\d*|return code [1-9]\d*)\b/i }
+    ];
+    HYPOTHESES = {
+      permission_denied: "permissions issue — check ownership and mode of the target; you may need to operate on a writeable location",
+      not_found: "the named resource doesn't exist at the expected location — verify the path/name with a single-line list before retrying",
+      connection_refused: "remote service is unreachable — verify it's running and reachable before retrying with the same address",
+      timeout: "operation took too long — reduce scope (smaller batch, fewer items) or verify the service is healthy",
+      syntax_error: "malformed input — re-read the surrounding context; the input you produced doesn't match what the consumer expects",
+      type_or_reference_error: "a name, type, or import doesn't resolve — verify the reference matches what's defined; do not guess at the symbol",
+      nonzero_exit: "the command exited with a failure code — read the FULL error output and verify args + prerequisites before retrying",
+      unknown: "re-read the full error message and identify the most likely cause; verify your assumption with a single small command before retrying"
+    };
+  }
+});
+
 // packages/orchestrator/dist/pressure-gate.js
 function detectPressure(message2) {
   const hasProfanity = PRESSURE_SIGNALS.test(message2);
@@ -518460,6 +518541,7 @@ var init_agenticRunner = __esm({
     init_personality();
     init_promptLoader();
     init_critic();
+    init_reflection();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -518586,6 +518668,14 @@ var init_agenticRunner = __esm({
       _errorPatterns = /* @__PURE__ */ new Map();
       _errorGuidanceInjected = /* @__PURE__ */ new Set();
       // prevent duplicate injection per turn
+      // REG-26 (Patch C): Reflexion-style structured failure memory. Indexed by
+      // fingerprint stem (tool + first arg, truncated). When the agent retries a
+      // tool with a stem matching a stored reflection, surface "what was tried,
+      // what went wrong, hypothesis to verify" as a system message before the
+      // dispatch — generic across all stacks. See packages/orchestrator/src/reflection.ts.
+      _failureReflections = /* @__PURE__ */ new Map();
+      _reflectionsInjectedThisTurn = /* @__PURE__ */ new Set();
+      // prevent duplicate inject per turn
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -520729,6 +520819,7 @@ TASK: ${task}` : task;
             break;
           }
           injectionsThisTurn = 0;
+          this._reflectionsInjectedThisTurn.clear();
           while (deferredSoftInjections.length > 0 && injectionsThisTurn < INJECTION_BUDGET_SOFT) {
             const next = deferredSoftInjections.shift();
             messages2.push({ role: next.role, content: next.content });
@@ -521598,6 +521689,16 @@ ${memoryLines.join("\n")}`
               if (observerRedundantBlock) {
                 this._littlemanRedundantBlocks.delete(toolFingerprint);
               }
+              {
+                const _reflStem = buildStem(tc.name, tc.arguments ?? {});
+                if (!this._reflectionsInjectedThisTurn.has(_reflStem)) {
+                  const _reflEntry = this._failureReflections.get(_reflStem);
+                  if (_reflEntry) {
+                    this._reflectionsInjectedThisTurn.add(_reflStem);
+                    pushSoftInjection("system", renderReflectionMessage(_reflEntry));
+                  }
+                }
+              }
               const criticDecision = evaluate({
                 proposedCall: { tool: tc.name, args: tc.arguments ?? {} },
                 fingerprint: toolFingerprint,
@@ -521624,6 +521725,11 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (criticDecision.decision === "force_progress_block") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
+                const _existingFp = recentToolResults.get(toolFingerprint);
+                if (_existingFp !== void 0) {
+                  recentToolResults.delete(toolFingerprint);
+                  recentToolResults.set(toolFingerprint, _existingFp);
+                }
                 this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                 this.emit({
                   type: "tool_result",
@@ -521637,6 +521743,11 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (criticDecision.decision === "serve_cached") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
+                const _existingFp = recentToolResults.get(toolFingerprint);
+                if (_existingFp !== void 0) {
+                  recentToolResults.delete(toolFingerprint);
+                  recentToolResults.set(toolFingerprint, _existingFp);
+                }
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -522062,6 +522173,8 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (result.success) {
                 this._recentFailures = this._recentFailures.filter((f2) => f2.fingerprint !== toolFingerprint);
+                const _stem = buildStem(tc.name, tc.arguments ?? {});
+                this._failureReflections.delete(_stem);
               }
               if (!result.success) {
                 this._recentFailures.push({
@@ -522075,6 +522188,22 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                 if (this._recentFailures.length > 8) {
                   this._recentFailures = this._recentFailures.slice(-8);
                 }
+                const _refStem = buildStem(tc.name, tc.arguments ?? {});
+                const _prior = this._failureReflections.get(_refStem);
+                const _refErr = (result.error ?? result.output ?? "").toString();
+                const _entry = synthesizeReflection({
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  errorText: _refErr,
+                  turn,
+                  priorAttempts: _prior?.attempts ?? 0
+                });
+                this._failureReflections.set(_refStem, _entry);
+                if (this._failureReflections.size > 32) {
+                  const oldestKey = this._failureReflections.keys().next().value;
+                  if (oldestKey !== void 0)
+                    this._failureReflections.delete(oldestKey);
+                }
               }
               if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
                 this.emit({
@@ -522340,9 +522469,35 @@ ${sr.result.output}`;
               for (const batch2 of batches) {
                 if (this.aborted)
                   break;
+                const batchFingerprintFirstId = /* @__PURE__ */ new Map();
+                const batchInFlight = /* @__PURE__ */ new Map();
+                const buildBatchFp = (call) => {
+                  const args = call.args ?? {};
+                  const argsKey = Object.entries(args).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
+                  return `${call.name}:${argsKey}`;
+                };
+                for (const call of batch2.calls) {
+                  const fp = buildBatchFp(call);
+                  if (!batchFingerprintFirstId.has(fp)) {
+                    batchFingerprintFirstId.set(fp, call.id);
+                  }
+                }
                 const results = await executeBatch(batch2, async (call) => {
                   const originalTc = rawToolCalls.find((tc) => tc.id === call.id);
-                  return executeSingle(originalTc);
+                  const fp = buildBatchFp(call);
+                  const firstId = batchFingerprintFirstId.get(fp);
+                  if (firstId !== void 0 && call.id !== void 0 && firstId !== call.id) {
+                    const inflight = batchInFlight.get(fp);
+                    if (inflight) {
+                      const cloned = await inflight;
+                      if (!cloned)
+                        return null;
+                      return { tc: { ...cloned.tc, id: call.id }, output: cloned.output };
+                    }
+                  }
+                  const promise = executeSingle(originalTc);
+                  batchInFlight.set(fp, promise);
+                  return promise;
                 }, 5);
                 for (const r2 of results) {
                   if (r2) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.479",
+  "version": "0.187.480",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.479",
+      "version": "0.187.480",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

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