open-agents-ai 0.11.5 → 0.11.7

package/dist/index.js

@@ -6588,7 +6588,9 @@ Commands run non-interactively (CI=true). When running scaffolding tools:
           taskTimeoutMs: options?.taskTimeoutMs ?? 12e5,
           compactionThreshold: options?.compactionThreshold ?? 4e4,
           dynamicContext: options?.dynamicContext ?? "",
-          streamEnabled: options?.streamEnabled ?? false
+          streamEnabled: options?.streamEnabled ?? false,
+          bruteForce: options?.bruteForce ?? false,
+          bruteForceMaxCycles: options?.bruteForceMaxCycles ?? 3
         };
       }
       /** Register a tool for the agent to use */
@@ -6638,9 +6640,11 @@ TASK: ${task}` : task }
         ];
         const toolDefs = this.buildToolDefinitions();
         let totalTokens = 0;
+        let estimatedTokens = 0;
         let toolCallCount = 0;
         let completed = false;
         let summary = "";
+        let bruteForceCycle = 0;
         for (let turn = 0; turn < this.options.maxTurns; turn++) {
           if (this.aborted) {
             this.emit({ type: "error", content: "Task aborted by user", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -6693,6 +6697,9 @@ Integrate this guidance into your current approach. Continue working on the task
           };
           const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           totalTokens += response.usage?.totalTokens ?? 0;
+          const choiceContent = response.choices[0]?.message?.content ?? "";
+          const choiceArgs = response.choices[0]?.message?.toolCalls?.map((tc) => JSON.stringify(tc.arguments)).join("") ?? "";
+          estimatedTokens += Math.ceil((choiceContent.length + choiceArgs.length) / 4);
           const choice = response.choices[0];
           if (!choice)
             break;
@@ -6771,6 +6778,122 @@ ${result.output}`;
             });
           }
         }
+        if (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < deadline) {
+          bruteForceCycle++;
+          const totalTurns = messages.filter((m) => m.role === "assistant").length;
+          this.emit({
+            type: "compaction",
+            content: `Brute-force cycle ${bruteForceCycle}/${this.options.bruteForceMaxCycles} \u2014 re-engaging agent`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          messages.push({
+            role: "user",
+            content: `[BRUTE-FORCE RE-ENGAGEMENT \u2014 Cycle ${bruteForceCycle}/${this.options.bruteForceMaxCycles}]
+
+You have used ${totalTurns} turns and ${toolCallCount} tool calls without completing the task. DO NOT give up. Reassess your approach:
+
+1. DIAGNOSE: What exactly is blocking progress? Read error messages carefully.
+2. PIVOT: If the current approach isn't working, try a completely different strategy.
+3. INVESTIGATE: Use grep_search, find_files, and web_search to find solutions.
+4. SIMPLIFY: Break the problem into smaller steps. Fix one thing at a time.
+5. VERIFY: Run tests/build after EVERY change \u2014 don't batch multiple changes.
+
+You have ${this.options.maxTurns} more turns. Be creative and investigative. If a file is confusing, re-read it. If a test fails, read the FULL error. Call task_complete when done.`
+          });
+          const compacted = this.compactMessages(messages);
+          messages.length = 0;
+          messages.push(...compacted);
+          for (let turn = 0; turn < this.options.maxTurns; turn++) {
+            if (this.aborted) {
+              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() });
+              break;
+            }
+            while (this.pendingUserMessages.length > 0) {
+              const userMsg = this.pendingUserMessages.shift();
+              const imagePattern = /\[IMAGE_BASE64:([^:]+):([^\]]+)\]/;
+              const imgMatch = userMsg.match(imagePattern);
+              if (imgMatch) {
+                const mime = imgMatch[1];
+                const base64 = imgMatch[2];
+                const textContent = userMsg.replace(imagePattern, "").trim();
+                const parts = [];
+                if (textContent) {
+                  parts.push({ type: "text", text: `[User added context]: ${textContent}
+
+Describe what you see and integrate this into your current approach.` });
+                } else {
+                  parts.push({ type: "text", text: "[User shared an image]. Describe what you see and integrate this into your current approach." });
+                }
+                parts.push({ type: "image_url", image_url: { url: `data:${mime};base64,${base64}` } });
+                messages.push({ role: "user", content: parts });
+              } else {
+                messages.push({ role: "user", content: `[User added context]: ${userMsg}
+
+Integrate this guidance into your current approach. Continue working on the task.` });
+              }
+              this.emit({ type: "user_interrupt", content: userMsg.replace(/\[IMAGE_BASE64:[^\]]+\]/, "[image]").slice(0, 200), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+            }
+            const compactedMsgs = this.compactMessages(messages);
+            const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
+            const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+            totalTokens += response.usage?.totalTokens ?? 0;
+            const choiceContent2 = response.choices[0]?.message?.content ?? "";
+            const choiceArgs2 = response.choices[0]?.message?.toolCalls?.map((tc) => JSON.stringify(tc.arguments)).join("") ?? "";
+            estimatedTokens += Math.ceil((choiceContent2.length + choiceArgs2.length) / 4);
+            const choice = response.choices[0];
+            if (!choice)
+              break;
+            const msg = choice.message;
+            if (msg.toolCalls && msg.toolCalls.length > 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)
+                  break;
+                toolCallCount++;
+                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;
+                if (!tool) {
+                  result = { success: false, output: "", error: `Unknown tool: ${tc.name}` };
+                } else {
+                  try {
+                    result = await tool.execute(tc.arguments);
+                  } catch (err) {
+                    result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
+                  }
+                }
+                const maxLen = 8e3;
+                const output = result.success ? result.output.length > maxLen ? result.output.slice(0, maxLen) + `
+...(truncated)` : result.output : `Error: ${result.error || "unknown error"}
+${result.output}`;
+                this.emit({ type: "tool_result", toolName: tc.name, content: output.slice(0, 200), success: result.success, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                const toolMsg = this.buildToolMessage(output, tc.id);
+                messages.push(toolMsg);
+                if (tc.name === "task_complete") {
+                  completed = true;
+                  summary = tc.arguments.summary || "";
+                  break;
+                }
+              }
+              if (completed)
+                break;
+            } else {
+              const content = msg.content || "";
+              messages.push({ role: "assistant", content });
+              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;
+              }
+              messages.push({ role: "user", content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done." });
+            }
+          }
+        }
         const durationMs = Date.now() - start;
         this.emit({
           type: "complete",
@@ -6778,7 +6901,7 @@ ${result.output}`;
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        return { completed, turns: messages.filter((m) => m.role === "assistant").length, toolCalls: toolCallCount, totalTokens, summary, durationMs };
+        return { completed, turns: messages.filter((m) => m.role === "assistant").length, toolCalls: toolCallCount, totalTokens, estimatedTokens, summary, durationMs };
       }
       // -------------------------------------------------------------------------
       // Image / multimodal support
@@ -7460,11 +7583,16 @@ function renderToolResult(toolName, success, output) {
 `);
   }
 }
-function renderTaskComplete(summary, turns, toolCalls, durationMs) {
+function renderTaskComplete(summary, turns, toolCalls, durationMs, tokens) {
   const duration = formatDuration2(durationMs);
+  const tokenStr = tokens ? ` ${formatTokenCount(tokens)}` : "";
   process.stdout.write(`
 ${c2.green("\u2714")} ${c2.bold("Task completed")} ${c2.dim(`(${turns} turns, ${toolCalls} tool calls, ${duration})`)}
 `);
+  if (tokenStr) {
+    process.stdout.write(`  ${c2.dim(tokenStr)}
+`);
+  }
   if (summary) {
     const lines = summary.split("\n");
     for (const line of lines) {
@@ -7474,12 +7602,26 @@ ${c2.green("\u2714")} ${c2.bold("Task completed")} ${c2.dim(`(${turns} turns, ${
   }
   process.stdout.write("\n");
 }
-function renderTaskIncomplete(turns, toolCalls, durationMs) {
+function renderTaskIncomplete(turns, toolCalls, durationMs, tokens) {
   const duration = formatDuration2(durationMs);
+  const tokenStr = tokens ? ` ${formatTokenCount(tokens)}` : "";
   process.stdout.write(`
 ${c2.yellow("\u26A0")} ${c2.bold("Task incomplete")} ${c2.dim(`(${turns} turns, ${toolCalls} tool calls, ${duration})`)}
-
 `);
+  if (tokenStr) {
+    process.stdout.write(`  ${c2.dim(tokenStr)}
+`);
+  }
+  process.stdout.write("\n");
+}
+function formatTokenCount(tokens) {
+  if (tokens.total > 0) {
+    return `Tokens: ${tokens.total.toLocaleString()}`;
+  }
+  if (tokens.estimated > 0) {
+    return `Tokens: ~${tokens.estimated.toLocaleString()} (estimated)`;
+  }
+  return "";
 }
 function renderError(message) {
   process.stdout.write(`
@@ -7565,6 +7707,7 @@ function renderSlashHelp() {
     ["/voice", "Toggle TTS voice feedback (GLaDOS)"],
     ["/voice <model>", "Set voice: glados, overwatch"],
     ["/stream", "Toggle real-time token streaming (pastel syntax highlighting)"],
+    ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -7844,6 +7987,7 @@ var init_render = __esm({
       "/voice",
       "/stream",
       "/verbose",
+      "/bruteforce",
       "/clear",
       "/help",
       "/quit"
@@ -7936,6 +8080,14 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Token streaming: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 thinking tokens in grey italics, responses with pastel syntax highlighting" : ""));
       return "handled";
     }
+    case "bruteforce":
+    case "brute": {
+      const isOn = ctx.bruteForceToggle();
+      const save = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      save({ bruteforce: isOn });
+      renderInfo(`Brute-force mode: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 agent will auto re-engage when turn limit is hit, reassess and try creative strategies" : ""));
+      return "handled";
+    }
     default:
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
@@ -9913,15 +10065,17 @@ var init_voice = __esm({
       }
       /**
        * Speak text asynchronously (non-blocking).
-       * Queues if already speaking; drops if queue gets too deep.
+       * Long text is chunked on sentence/line boundaries for reliable TTS.
+       * Chunks are queued FIFO and played back-to-back without cutoff.
        */
       speak(text) {
         if (!this.enabled || !this.ready)
           return;
-        if (this.speakQueue.length >= 3) {
+        const chunks = this.chunkText(text);
+        if (this.speakQueue.length >= 30) {
           this.speakQueue.length = 0;
         }
-        this.speakQueue.push(text);
+        this.speakQueue.push(...chunks);
         if (!this.speaking) {
           this.drainQueue().catch(() => {
           });
@@ -9935,13 +10089,47 @@ var init_voice = __esm({
         this.config = null;
       }
       // -------------------------------------------------------------------------
+      // Text chunking for long TTS input
+      // -------------------------------------------------------------------------
+      /**
+       * Split long text into sentence-sized chunks suitable for ONNX TTS.
+       * Splits on: newlines (list items, paragraphs), then sentence-ending
+       * punctuation (.!?). Short text (<= 200 chars) passes through unchanged.
+       */
+      chunkText(text) {
+        if (text.length <= 200)
+          return [text];
+        const chunks = [];
+        const lines = text.split(/\n+/);
+        for (const line of lines) {
+          const trimmed = line.replace(/^[\s\-*•]+/, "").trim();
+          if (!trimmed)
+            continue;
+          if (trimmed.length <= 200) {
+            chunks.push(trimmed);
+          } else {
+            const sentences = trimmed.split(/(?<=[.!?])\s+/);
+            for (const sentence of sentences) {
+              const s = sentence.trim();
+              if (s)
+                chunks.push(s);
+            }
+          }
+        }
+        return chunks.length > 0 ? chunks : [text.slice(0, 200)];
+      }
+      // -------------------------------------------------------------------------
       // Queue drain
       // -------------------------------------------------------------------------
+      /**
+       * Drain the speak queue FIFO — each item is synthesized and played to
+       * completion before the next starts.  Items play back-to-back without
+       * cutting off previous audio.
+       */
       async drainQueue() {
         this.speaking = true;
         while (this.speakQueue.length > 0) {
-          const text = this.speakQueue.pop();
-          this.speakQueue.length = 0;
+          const text = this.speakQueue.shift();
           try {
             await this.synthesizeAndPlay(text);
           } catch {
@@ -10061,7 +10249,6 @@ var init_voice = __esm({
       // Audio playback (system default speakers)
       // -------------------------------------------------------------------------
       async playWav(path) {
-        this.killPlayback();
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
@@ -10082,7 +10269,13 @@ var init_voice = __esm({
             resolve14();
           });
           setTimeout(() => {
-            this.killPlayback();
+            if (this.currentPlayback === child) {
+              try {
+                child.kill("SIGTERM");
+              } catch {
+              }
+              this.currentPlayback = null;
+            }
             resolve14();
           }, 15e3);
         });
@@ -10680,7 +10873,7 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce) {
   const projectCtx = buildProjectContext(repoRoot, taskStores?.contextStores);
   const dynamicContext = formatContextForPrompt(projectCtx);
   const backend = new OllamaAgenticBackend(config.backendUrl.replace(/\/$/, ""), config.model);
@@ -10692,7 +10885,8 @@ function startTask(task, config, repoRoot, voice, stream, taskStores) {
     taskTimeoutMs: config.timeoutMs * 4,
     compactionThreshold: 4e4,
     dynamicContext,
-    streamEnabled: stream?.enabled ?? false
+    streamEnabled: stream?.enabled ?? false,
+    bruteForce: bruteForce ?? false
   });
   runner.registerTools(buildTools(repoRoot, config));
   const filesTouched = /* @__PURE__ */ new Set();
@@ -10754,14 +10948,15 @@ function startTask(task, config, repoRoot, voice, stream, taskStores) {
   });
   const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const promise = runner.run(task, `Working directory: ${repoRoot}`).then((result) => {
+    const tokens = { total: result.totalTokens, estimated: result.estimatedTokens };
     if (result.completed) {
-      renderTaskComplete(result.summary, result.turns, result.toolCalls, result.durationMs);
+      renderTaskComplete(result.summary, result.turns, result.toolCalls, result.durationMs, tokens);
       if (voice?.enabled && result.summary) {
         const ttsText = result.summary.length > 300 ? result.summary.slice(0, 300) + "..." : result.summary;
         voice.speak(`Task complete. ${ttsText}`);
       }
     } else {
-      renderTaskIncomplete(result.turns, result.toolCalls, result.durationMs);
+      renderTaskIncomplete(result.turns, result.toolCalls, result.durationMs, tokens);
       if (voice?.enabled) {
         voice.speak("Task did not complete.");
       }
@@ -10837,6 +11032,7 @@ async function startInteractive(config, repoPath) {
   if (savedSettings.dbPath)
     config = { ...config, dbPath: savedSettings.dbPath };
   let streamEnabled = savedSettings.stream ?? false;
+  let bruteForceEnabled = savedSettings.bruteforce ?? false;
   if (!isResumed) {
     const needsSetup = isFirstRun() || !await isModelAvailable(config);
     if (needsSetup && config.backendType === "ollama") {
@@ -10965,6 +11161,10 @@ async function startInteractive(config, repoPath) {
       streamEnabled = !streamEnabled;
       return streamEnabled;
     },
+    bruteForceToggle() {
+      bruteForceEnabled = !bruteForceEnabled;
+      return bruteForceEnabled;
+    },
     saveSettings(settings) {
       try {
         saveProjectSettings(repoRoot, settings);
@@ -11048,7 +11248,7 @@ ${c2.dim("Goodbye!")}
         contextStores,
         taskMemoryStore: taskMemoryStore ?? void 0,
         failureStore: failureStore ?? void 0
-      });
+      }, bruteForceEnabled);
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -11772,10 +11972,11 @@ var init_config3 = __esm({
       dbPath: "Path to SQLite memory database",
       voice: "Enable TTS voice feedback (true/false)",
       voiceModel: "TTS voice model: glados, overwatch",
-      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)"
+      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)",
+      bruteforce: "Brute-force mode: auto re-engage agent when turn limit hit (true/false)"
     };
     INT_KEYS = /* @__PURE__ */ new Set(["maxRetries", "timeoutMs"]);
-    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream"]);
+    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream", "bruteforce"]);
   }
 });
 

package/package.json

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