open-agents-ai 0.180.0 → 0.182.0

package/dist/index.js

@@ -25840,6 +25840,38 @@ Now call file_write with YOUR skeleton for this task.`
               });
             }
           }
+          if (turn === 0 && (turnTier === "small" || turnTier === "medium")) {
+            const taskGoal = this._taskState.goal || "";
+            const taskLower = taskGoal.toLowerCase();
+            const taskTokens = new Set(taskLower.split(/\s+/).filter((w) => w.length > 2));
+            const CORE = /* @__PURE__ */ new Set(["file_read", "file_write", "file_edit", "shell", "task_complete", "grep_search", "find_files", "list_directory", "file_explore"]);
+            const toolHints = [];
+            for (const tool of this.tools.values()) {
+              if (CORE.has(tool.name))
+                continue;
+              const toolWords = `${tool.name.replace(/_/g, " ")} ${tool.description}`.toLowerCase().split(/\s+/);
+              let score = 0;
+              for (const tw of toolWords) {
+                if (taskTokens.has(tw))
+                  score += 2;
+                for (const qt of taskTokens) {
+                  if (tw.length > 3 && qt.length > 3 && (tw.includes(qt) || qt.includes(tw)))
+                    score += 1;
+                }
+              }
+              if (score > 2)
+                toolHints.push({ name: tool.name, desc: tool.description.slice(0, 80), score });
+            }
+            if (toolHints.length > 0) {
+              toolHints.sort((a, b) => b.score - a.score);
+              const top = toolHints.slice(0, 5);
+              messages.push({
+                role: "system",
+                content: `[Relevant tools for this task]
+${top.map((t) => `- ${t.name}: ${t.desc}`).join("\n")}`
+              });
+            }
+          }
           const turnBudget = turnTier === "small" ? 5 : turnTier === "medium" ? 8 : 0;
           if (turnBudget > 0 && turn > 0 && turn % turnBudget === 0) {
             const repetitionRatio = this.detectRepetition(toolCallLog);
@@ -27833,14 +27865,79 @@ ${transcript}`
       // -------------------------------------------------------------------------
       // Tool definition builder
       // -------------------------------------------------------------------------
+      /**
+       * Build tool definitions with task-aware filtering for small models.
+       *
+       * Research basis:
+       * - Gorilla (arXiv:2305.15334): RAG-for-tools, 7B outperforms GPT-4 with tool retrieval
+       * - EASYTOOL (arXiv:2401.06201): Minimal tool descriptions reduce tokens 40-70%
+       * - ToolLLM (arXiv:2307.16789): Progressive tool discovery improves small model accuracy
+       *
+       * For small/medium models: only include core tools + task-relevant tools.
+       * For large models: include everything (they can handle the context).
+       */
       buildToolDefinitions() {
-        return Array.from(this.tools.values()).map((tool) => ({
-          type: "function",
-          function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters
+        const allTools = Array.from(this.tools.values());
+        const tier = this.options.modelTier;
+        if (tier === "large") {
+          return allTools.map((tool) => ({
+            type: "function",
+            function: { name: tool.name, description: tool.description, parameters: tool.parameters }
+          }));
+        }
+        const CORE_TOOLS = /* @__PURE__ */ new Set([
+          "file_read",
+          "file_write",
+          "file_edit",
+          "shell",
+          "task_complete",
+          "grep_search",
+          "find_files",
+          "list_directory",
+          "file_explore"
+        ]);
+        const taskText = (this._taskState.goal || "").toLowerCase();
+        const taskWords = new Set(taskText.split(/\s+/).filter((w) => w.length > 2));
+        const scored = [];
+        for (const tool of allTools) {
+          if (CORE_TOOLS.has(tool.name))
+            continue;
+          const toolText = `${tool.name} ${tool.description}`.toLowerCase();
+          const toolWords = toolText.split(/\s+/).filter((w) => w.length > 2);
+          let score = 0;
+          for (const tw of toolWords) {
+            if (taskWords.has(tw))
+              score += 2;
+            for (const qw of taskWords) {
+              if (tw.includes(qw) || qw.includes(tw))
+                score += 1;
+            }
           }
+          if (taskText.includes(tool.name.replace(/_/g, " ")) || taskText.includes(tool.name)) {
+            score += 10;
+          }
+          if (["web_search", "web_fetch", "memory_read", "memory_write", "memory_search"].includes(tool.name)) {
+            score += 1;
+          }
+          scored.push({ tool, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        const maxExtra = tier === "small" ? 6 : 12;
+        const relevantTools = scored.slice(0, maxExtra).filter((s) => s.score > 0);
+        const selectedTools = [
+          ...allTools.filter((t) => CORE_TOOLS.has(t.name)),
+          ...relevantTools.map((s) => s.tool)
+        ];
+        const seen = /* @__PURE__ */ new Set();
+        const deduped = selectedTools.filter((t) => {
+          if (seen.has(t.name))
+            return false;
+          seen.add(t.name);
+          return true;
+        });
+        return deduped.map((tool) => ({
+          type: "function",
+          function: { name: tool.name, description: tool.description, parameters: tool.parameters }
         }));
       }
       // -------------------------------------------------------------------------
@@ -51373,10 +51470,32 @@ var init_stream_renderer = __esm({
        * Feed a streamed token into the renderer.
        * Tokens are buffered per-line and flushed with syntax highlighting.
        */
+      /** Track whether we've shown the thinking indicator */
+      thinkingIndicatorShown = false;
+      thinkingTokenCount = 0;
       write(token, kind) {
         if (!this.enabled)
           return;
         this.tokenCount++;
+        if (kind === "thinking") {
+          this.thinkingTokenCount++;
+          if (!this.thinkingIndicatorShown) {
+            this.thinkingIndicatorShown = true;
+            this.writeRaw(dimText("  \u23BF  ") + dimItalic("thinking...") + "\n");
+            this.lineStarted = false;
+          }
+          if (this.thinkingTokenCount % 50 === 0) {
+            process.stdout.write(`\x1B[1A\x1B[2K${dimText("  \u23BF  ")}${dimItalic(`thinking... (${this.thinkingTokenCount} tokens)`)}
+`);
+          }
+          return;
+        }
+        if (this.thinkingIndicatorShown && kind === "content") {
+          this.thinkingIndicatorShown = false;
+          process.stdout.write(`\x1B[1A\x1B[2K${dimText("  \u23BF  ")}${dimItalic(`thought for ${this.thinkingTokenCount} tokens`)}
+`);
+          this.thinkingTokenCount = 0;
+        }
         if (kind === "tool_args" && !this.inToolArgs) {
           this.flushPartial(kind);
           this.inToolArgs = true;
@@ -57427,8 +57546,8 @@ var init_status_bar = __esm({
       /** Mouse tracking state — disabled when idle to allow native text selection */
       _mouseTrackingEnabled = true;
       _mouseIdleTimer = null;
-      static MOUSE_IDLE_MS = 1500;
-      // disable after 1.5s idle
+      static MOUSE_IDLE_MS = 500;
+      // disable after 0.5s idle — fast enough for text selection
       /** Text selection state — tracks click-drag selection for copy */
       _textSelection = new TextSelection({
         getContentLines: () => this._contentLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.180.0",
+  "version": "0.182.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",