open-agents-ai 0.12.4 → 0.12.5

package/dist/index.js

@@ -7421,10 +7421,49 @@ If you notice you're performing the SAME multi-step sequence for the 3rd time or
           }
         }
       }
+      /**
+       * Detect repetition in recent tool calls.
+       * Returns a score 0-1 where 1 = fully repetitive (stuck in a loop).
+       */
+      detectRepetition(recentToolCalls) {
+        if (recentToolCalls.length < 4)
+          return 0;
+        const window = recentToolCalls.slice(-8);
+        const uniqueKeys = new Set(window.map((tc) => `${tc.name}:${tc.argsKey}`));
+        const ratio = 1 - uniqueKeys.size / window.length;
+        return ratio;
+      }
+      /**
+       * Build a self-eval prompt for the agent when approaching timeout.
+       * Returns the prompt to inject. The agent will respond with a plan.
+       */
+      buildTimeoutSelfEvalPrompt(elapsedMs2, toolCallCount, repetitionScore, remainingMs) {
+        const elapsedMin = (elapsedMs2 / 6e4).toFixed(1);
+        const remainingMin = (remainingMs / 6e4).toFixed(1);
+        const stuckWarning = repetitionScore > 0.5 ? `
+\u26A0 REPETITION DETECTED: Your recent tool calls are ${Math.round(repetitionScore * 100)}% repetitive. You may be stuck in a loop.` : "";
+        return `[TIMEOUT APPROACHING \u2014 Self-Assessment Required]
+
+You have been working for ${elapsedMin} minutes with ${toolCallCount} tool calls. You have approximately ${remainingMin} minutes remaining.${stuckWarning}
+
+ASSESS YOUR SITUATION and choose ONE action:
+
+1. CONTINUE \u2014 If you are making genuine progress on a long task, say "CONTINUE" and briefly explain what progress you've made and what remains. You will get an extended time window.
+
+2. PIVOT \u2014 If your current approach isn't working, say "PIVOT" and describe a completely different strategy. Then immediately try that new approach.
+
+3. CHECKPOINT \u2014 If you've made partial progress, say "CHECKPOINT" and call task_complete with a summary of what you accomplished so far. The user can continue from where you left off.
+
+Respond with your assessment, then take action. Do NOT just say you'll continue without explaining concrete progress. Be honest about whether you're stuck.`;
+      }
       /** Run a task through the agentic loop */
       async run(task, context) {
         const start = Date.now();
-        const deadline = start + this.options.taskTimeoutMs;
+        const taskTimeoutMs = this.options.taskTimeoutMs;
+        const softDeadline = start + Math.floor(taskTimeoutMs * 0.8);
+        const hardDeadline = start + Math.floor(taskTimeoutMs * 1.5);
+        let softTimeoutTriggered = false;
+        const toolCallLog = [];
         this.aborted = false;
         this.pendingUserMessages.length = 0;
         const systemPrompt = this.options.dynamicContext ? `${SYSTEM_PROMPT}
@@ -7448,10 +7487,26 @@ TASK: ${task}` : task }
             this.emit({ type: "error", content: "Task aborted by user", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
             break;
           }
-          if (Date.now() > deadline) {
-            this.emit({ type: "error", content: "Task timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+          const now = Date.now();
+          if (now > hardDeadline) {
+            this.emit({ type: "error", content: "Task hard timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
             break;
           }
+          if (!softTimeoutTriggered && now > softDeadline) {
+            softTimeoutTriggered = true;
+            const elapsed = now - start;
+            const remaining = hardDeadline - now;
+            const repetitionScore = this.detectRepetition(toolCallLog);
+            this.emit({
+              type: "compaction",
+              content: `Timeout approaching (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 injecting self-assessment`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            messages.push({
+              role: "user",
+              content: this.buildTimeoutSelfEvalPrompt(elapsed, toolCallCount, repetitionScore, remaining)
+            });
+          }
           while (this.pendingUserMessages.length > 0) {
             const userMsg = this.pendingUserMessages.shift();
             const imagePattern = /\[IMAGE_BASE64:([^:]+):([^\]]+)\]/;
@@ -7516,6 +7571,8 @@ Integrate this guidance into your current approach. Continue working on the task
               if (this.aborted)
                 break;
               toolCallCount++;
+              const argsKey = Object.keys(tc.arguments ?? {}).sort().join(",");
+              toolCallLog.push({ name: tc.name, argsKey });
               this.emit({
                 type: "tool_call",
                 toolName: tc.name,
@@ -7576,7 +7633,7 @@ ${result.output}`;
             });
           }
         }
-        if (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < deadline) {
+        if (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < hardDeadline) {
           bruteForceCycle++;
           const totalTurns = messages.filter((m) => m.role === "assistant").length;
           this.emit({
@@ -7606,10 +7663,26 @@ You have ${this.options.maxTurns} more turns. Be creative and investigative. If
               this.emit({ type: "error", content: "Task aborted by user", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
               break;
             }
-            if (Date.now() > deadline) {
-              this.emit({ type: "error", content: "Task timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+            const bfNow = Date.now();
+            if (bfNow > hardDeadline) {
+              this.emit({ type: "error", content: "Task hard timeout reached", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
               break;
             }
+            if (!softTimeoutTriggered && bfNow > softDeadline) {
+              softTimeoutTriggered = true;
+              const elapsed = bfNow - start;
+              const remaining = hardDeadline - bfNow;
+              const repetitionScore = this.detectRepetition(toolCallLog);
+              this.emit({
+                type: "compaction",
+                content: `Timeout approaching (${(elapsed / 6e4).toFixed(1)}m elapsed) \u2014 injecting self-assessment`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              messages.push({
+                role: "user",
+                content: this.buildTimeoutSelfEvalPrompt(elapsed, toolCallCount, repetitionScore, remaining)
+              });
+            }
             while (this.pendingUserMessages.length > 0) {
               const userMsg = this.pendingUserMessages.shift();
               const imagePattern = /\[IMAGE_BASE64:([^:]+):([^\]]+)\]/;
@@ -7652,6 +7725,7 @@ Integrate this guidance into your current approach. Continue working on the task
                 if (this.aborted)
                   break;
                 toolCallCount++;
+                toolCallLog.push({ name: tc.name, argsKey: Object.keys(tc.arguments ?? {}).sort().join(",") });
                 this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                 const tool = this.tools.get(tc.name);
                 let result;

package/package.json

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