open-agents-ai 0.88.0 → 0.90.0

package/dist/index.js

@@ -16487,6 +16487,8 @@ TASK: ${task}` : task }
         let completed = false;
         let summary = "";
         let bruteForceCycle = 0;
+        let consecutiveTextOnly = 0;
+        const MAX_CONSECUTIVE_TEXT_ONLY = 3;
         for (let turn = 0; turn < this.options.maxTurns; turn++) {
           if (this._paused) {
             const shouldContinue = await this.waitIfPaused();
@@ -16600,6 +16602,7 @@ Integrate this guidance into your current approach. Continue working on the task
             break;
           const msg = choice.message;
           if (msg.toolCalls && msg.toolCalls.length > 0) {
+            consecutiveTextOnly = 0;
             messages.push({
               role: "assistant",
               content: msg.content || null,
@@ -16775,6 +16778,7 @@ Do NOT continue walking up parent directories.`);
           } else {
             const content = msg.content || "";
             messages.push({ role: "assistant", content });
+            consecutiveTextOnly++;
             this.emit({
               type: "model_response",
               content: content.slice(0, 200),
@@ -16786,15 +16790,34 @@ Do NOT continue walking up parent directories.`);
               summary = content;
               break;
             }
+            if (consecutiveTextOnly >= MAX_CONSECUTIVE_TEXT_ONLY) {
+              this.emit({
+                type: "status",
+                content: `Model returned ${consecutiveTextOnly} consecutive text-only responses without using tools \u2014 breaking turn loop to avoid runaway`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              break;
+            }
             messages.push({
               role: "user",
               content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done."
             });
           }
         }
+        let prevCycleToolCalls = toolCallCount;
         while (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
           bruteForceCycle++;
           const totalTurns = messages.filter((m) => m.role === "assistant").length;
+          if (bruteForceCycle > 1 && toolCallCount === prevCycleToolCalls) {
+            this.emit({
+              type: "status",
+              content: `Stopping re-engagement \u2014 no tool call progress in cycle ${bruteForceCycle - 1}. Model may not support tool calling for this task.`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            break;
+          }
+          prevCycleToolCalls = toolCallCount;
+          consecutiveTextOnly = 0;
           this.emit({
             type: "status",
             content: `Re-engaging \u2014 cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} tool calls so far)`,
@@ -16918,6 +16941,7 @@ Integrate this guidance into your current approach. Continue working on the task
               break;
             const msg = choice.message;
             if (msg.toolCalls && msg.toolCalls.length > 0) {
+              consecutiveTextOnly = 0;
               messages.push({ role: "assistant", content: msg.content || null, tool_calls: msg.toolCalls.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } })) });
               for (const tc of msg.toolCalls) {
                 if (this.aborted)
@@ -16978,12 +17002,21 @@ Do NOT continue walking up parent directories.`);
             } else {
               const content = msg.content || "";
               messages.push({ role: "assistant", content });
+              consecutiveTextOnly++;
               this.emit({ type: "model_response", content: content.slice(0, 200), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
               if (/task.?complete|all tests pass/i.test(content)) {
                 completed = true;
                 summary = content;
                 break;
               }
+              if (consecutiveTextOnly >= MAX_CONSECUTIVE_TEXT_ONLY) {
+                this.emit({
+                  type: "status",
+                  content: `Model returned ${consecutiveTextOnly} consecutive text-only responses \u2014 breaking cycle ${bruteForceCycle}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                break;
+              }
               messages.push({ role: "user", content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done." });
             }
           }
@@ -18325,6 +18358,49 @@ var init_nexusBackend = __esm({
           usage: this.extractUsage(responseData)
         };
       }
+      /**
+       * Simulated streaming: calls chatCompletion() for the full response,
+       * then yields it as word-level StreamChunk objects.
+       * Gives API compatibility with the streaming path in AgenticRunner.
+       */
+      async *chatCompletionStream(request) {
+        const response = await this.chatCompletion(request);
+        const choice = response.choices[0];
+        if (!choice)
+          return;
+        const msg = choice.message;
+        if (msg.content) {
+          const words = msg.content.split(/(\s+)/);
+          for (const word of words) {
+            if (word) {
+              yield { type: "content", content: word };
+            }
+          }
+        }
+        if (msg.toolCalls) {
+          for (let i = 0; i < msg.toolCalls.length; i++) {
+            const tc = msg.toolCalls[i];
+            yield {
+              type: "tool_call_delta",
+              toolCallIndex: i,
+              toolCallId: tc.id,
+              toolCallName: tc.name,
+              toolCallArgs: JSON.stringify(tc.arguments)
+            };
+          }
+        }
+        if (response.usage) {
+          yield {
+            type: "usage",
+            usage: {
+              promptTokens: response.usage.promptTokens ?? 0,
+              completionTokens: response.usage.completionTokens ?? 0,
+              totalTokens: response.usage.totalTokens
+            }
+          };
+        }
+        yield { type: "finish", finishReason: "stop" };
+      }
       extractUsage(data) {
         const usage = data.usage;
         if (!usage)
@@ -18341,6 +18417,60 @@ var init_nexusBackend = __esm({
   }
 });
 
+// packages/orchestrator/dist/flowstatePrompt.js
+var FLOWSTATE_PROMPT;
+var init_flowstatePrompt = __esm({
+  "packages/orchestrator/dist/flowstatePrompt.js"() {
+    "use strict";
+    FLOWSTATE_PROMPT = `## FlowState Protocol (Active)
+
+You are operating in FlowState mode. Apply this protocol to every task:
+
+### Pre-Task (Engage)
+- Clear context of noise \u2014 compact if SNR is degraded
+- Set ridiculously specific sub-goals (not "fix things" but "change line 47 of auth.ts to check for null")
+- Begin immediately \u2014 first tool call in first response (response inhibition)
+- Identify the first concrete action before reasoning further
+
+### During Task (Struggle -> Release -> Flow)
+- Execute the highest-impact action first (goal-directedness)
+- Maintain tight feedback loops: execute, verify, learn (immediate feedback)
+- Calibrate task complexity: chunk if overwhelming, compress if trivial (challenge-skill balance)
+- Rotate approaches when stuck: different tools, different angles (oasis effect)
+- Minimize context pollution: archive large outputs, compact when needed (minimalism)
+- Never research when you can act; never read when you can execute
+- Track your own token allocation: maximize flow-tokens (core reasoning), minimize junk-tokens (unnecessary elaboration)
+
+### Between Tasks (Recovery)
+- Compact context aggressively (active recovery, not passive degradation)
+- Update persistent memory with learnings (consolidation)
+- Clear the todo list \u2014 identify next highest-impact action (power-down ritual)
+- Assess context quality and improve if degraded
+
+### Flowstate Checklist (verify before each major action)
+- [ ] Is the goal ridiculously clear? (specific file, line, change \u2014 not vague intent)
+- [ ] Is context clean? (no irrelevant history cluttering working memory)
+- [ ] Is the first action identified? (a specific tool call, not more research)
+- [ ] Is the feedback loop tight? (verification command defined before making changes)
+- [ ] Is recovery planned? (compaction strategy selected for after task)
+
+### The Diagnostic Compass (when stuck)
+| Symptom | Variable | Fix |
+|---|---|---|
+| Working on the wrong thing | Goal-Directedness | Re-target. Find the most direct path. |
+| Underleveraged | Leverage | Parallelize. Use sub-agents. Build reusable systems. |
+| Distracted, fractured, unable to sustain depth | Flow | Remove friction. Reduce cognitive load. Create immersion. |
+
+### Peak Performance Equation
+Peak Performance = Goal-Directedness x Leverage x Flow
+(These MULTIPLY \u2014 a zero in any one collapses the entire equation)
+
+### Mantra
+Flow follows focus. Focus follows clarity. Clarity follows constraint.
+Constrain your context. Clarify your target. Focus your tools. Flow will follow.`;
+  }
+});
+
 // packages/orchestrator/dist/costTracker.js
 var DEFAULT_PRICING, CostTracker;
 var init_costTracker = __esm({
@@ -18821,6 +18951,7 @@ var init_dist5 = __esm({
     init_retryController();
     init_agenticRunner();
     init_nexusBackend();
+    init_flowstatePrompt();
     init_costTracker();
     init_workEvaluator();
     init_sessionMetrics();
@@ -23674,6 +23805,7 @@ function renderSlashHelp() {
     ["/compact <strategy>", "Compact with strategy: aggressive, decisions, errors, summary, structured"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/deep", "Toggle deep context \u2014 relaxes compaction so large models use 85% of context"],
+    ["/flow", "Toggle FlowState protocol \u2014 immediate action, tight loops, goal clarity"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
     ["/skills <keyword>", "Filter skills by name or trigger"],
@@ -29386,6 +29518,18 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Deep context mode: ${isOn ? "ON" : "OFF"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 compaction relaxed to 85% of context window. Large models will retain more working memory for complex reasoning." : " \u2014 compaction restored to default thresholds."));
       return "handled";
     }
+    case "flow":
+    case "flowstate": {
+      if (!ctx.flowToggle) {
+        renderWarning("FlowState not available");
+        return "handled";
+      }
+      const isFlowOn = ctx.flowToggle();
+      const flowSave = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      flowSave({ flow: isFlowOn });
+      renderInfo(`FlowState protocol: ${isFlowOn ? "ON" : "OFF"}${hasLocal ? " (project-local)" : ""}` + (isFlowOn ? " \u2014 agent will follow FlowState protocol: immediate action, tight feedback loops, goal clarity, challenge-skill calibration." : " \u2014 standard agent behavior restored."));
+      return "handled";
+    }
     case "emojis":
     case "emoji": {
       const current = ctx.getEmojis?.() ?? true;
@@ -39630,7 +39774,7 @@ function formatDMNToolArgs(toolName, args) {
       return "";
   }
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine, flowEnabled) {
   const voiceStyleMap = {
     concise: 1,
     balanced: 3,
@@ -39644,6 +39788,9 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   if (taskType && modelTier !== "small") {
     dynamicContext += "\n\n" + buildTaskContext(taskType);
   }
+  if (flowEnabled) {
+    dynamicContext += "\n\n" + FLOWSTATE_PROMPT;
+  }
   let backend;
   if (config.backendType === "nexus") {
     const nexusTool = new NexusTool(repoRoot);
@@ -40042,6 +40189,7 @@ async function startInteractive(config, repoPath) {
   let bruteForceEnabled = savedSettings.bruteforce ?? true;
   let currentStyle = PRESET_NAMES.includes(savedSettings.style) ? savedSettings.style : "balanced";
   let deepContextEnabled = savedSettings.deepContext ?? false;
+  let flowEnabled = savedSettings.flow === true;
   if (savedSettings.emojis !== void 0)
     setEmojisEnabled(savedSettings.emojis);
   if (savedSettings.colors !== void 0)
@@ -40574,6 +40722,10 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       deepContextEnabled = !deepContextEnabled;
       return deepContextEnabled;
     },
+    flowToggle() {
+      flowEnabled = !flowEnabled;
+      return flowEnabled;
+    },
     setStyle(preset) {
       currentStyle = preset;
     },
@@ -41547,7 +41699,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
           }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary, meta) => {
             lastCompletedSummary = summary;
             lastTaskMeta = meta ?? null;
-          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
+          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine, flowEnabled);
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -41764,7 +41916,7 @@ NEW TASK: ${fullInput}`;
       }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary, meta) => {
         lastCompletedSummary = summary;
         lastTaskMeta = meta ?? null;
-      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
+      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine, flowEnabled);
       activeTask = task;
       showPrompt();
       await task.promise;

package/package.json

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