open-agents-ai 0.187.13 → 0.187.14

package/dist/index.js

@@ -260278,6 +260278,49 @@ ${this.options.dynamicContext}`,
           repetitionWindow
         };
       }
+      /**
+       * WO-CE-02: Microcompact — lightweight per-turn function result clearing.
+       *
+       * Scans messages array and replaces old tool results with a compact marker.
+       * Keeps the most recent K results intact (K scales by model tier).
+       * This is NOT summarization — just replacement. No LLM call needed.
+       *
+       * Hannover reference: services/compact/apiMicrocompact.ts
+       * Research: arXiv:2307.03172 (Lost in the Middle — recent context matters most)
+       */
+      microcompact(messages2) {
+        const tier = this.options.modelTier ?? "large";
+        const keepResults = tier === "small" ? 6 : tier === "medium" ? 10 : 20;
+        const toolResultIndices = [];
+        for (let i2 = 0; i2 < messages2.length; i2++) {
+          if (messages2[i2].role === "tool") {
+            toolResultIndices.push(i2);
+          }
+        }
+        if (toolResultIndices.length <= keepResults)
+          return;
+        const clearCount = toolResultIndices.length - keepResults;
+        const toClear = toolResultIndices.slice(0, clearCount);
+        let cleared = 0;
+        for (const idx of toClear) {
+          const msg = messages2[idx];
+          const content = typeof msg.content === "string" ? msg.content : "";
+          if (content.startsWith("[Tool result cleared") || content.length < 100)
+            continue;
+          messages2[idx] = {
+            ...msg,
+            content: `[Tool result cleared \u2014 write down important findings from earlier results as they may be cleared]`
+          };
+          cleared++;
+        }
+        if (cleared > 0) {
+          this.emit({
+            type: "status",
+            content: `Microcompact: cleared ${cleared} old tool result(s), keeping ${keepResults} recent`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
       /** Register a tool for the agent to use */
       registerTool(tool) {
         this.tools.set(tool.name, tool);
@@ -260751,6 +260794,7 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             } catch {
             }
           }
+          this.microcompact(compacted);
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -261530,6 +261574,7 @@ Integrate this guidance into your current approach. Continue working on the task
             } else {
               compactedMsgs = await this.compactMessages(messages2, this._skillCompactionStrategy ?? "default");
             }
+            this.microcompact(compactedMsgs);
             const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
             let response;
             try {
@@ -262897,7 +262942,13 @@ ${transcript}`
           "grep_search",
           "find_files",
           "list_directory",
-          "file_explore"
+          "file_explore",
+          "web_search",
+          "web_fetch",
+          "memory_read",
+          "memory_write",
+          "working_notes",
+          "batch_edit"
         ]);
         const taskText = (this._taskState.goal || "").toLowerCase();
         const taskWords = new Set(taskText.split(/\s+/).filter((w) => w.length > 2));
@@ -262919,29 +262970,88 @@ ${transcript}`
           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)) {
+          if (["explore_tools", "memory_search", "skill_list", "skill_execute", "agent", "sub_agent"].includes(tool.name)) {
             score += 1;
           }
           scored.push({ tool, score });
         }
         scored.sort((a2, b) => b.score - a2.score);
-        const maxExtra = tier === "small" ? 6 : 12;
-        const relevantTools = scored.slice(0, maxExtra).filter((s2) => s2.score > 0);
-        const selectedTools = [
-          ...allTools.filter((t2) => CORE_TOOLS2.has(t2.name)),
-          ...relevantTools.map((s2) => s2.tool)
-        ];
+        const maxInlineExtra = tier === "small" ? 4 : 8;
+        const inlineExtras = scored.slice(0, maxInlineExtra).filter((s2) => s2.score > 0);
+        const inlineNames = /* @__PURE__ */ new Set([
+          ...allTools.filter((t2) => CORE_TOOLS2.has(t2.name)).map((t2) => t2.name),
+          ...inlineExtras.map((s2) => s2.tool.name)
+        ]);
+        const deferred = allTools.filter((t2) => !inlineNames.has(t2.name));
+        const inlineTools = allTools.filter((t2) => inlineNames.has(t2.name));
         const seen = /* @__PURE__ */ new Set();
-        const deduped = selectedTools.filter((t2) => {
+        const dedupedInline = inlineTools.filter((t2) => {
           if (seen.has(t2.name))
             return false;
           seen.add(t2.name);
           return true;
         });
-        return deduped.map((tool) => ({
+        const defs = dedupedInline.map((tool) => ({
           type: "function",
           function: { name: tool.name, description: tool.description, parameters: tool.parameters }
         }));
+        if (deferred.length > 0) {
+          const catalog = deferred.map((t2) => {
+            const shortDesc = t2.description.split(/\.\s/)[0]?.slice(0, 80) ?? t2.description.slice(0, 80);
+            return `- ${t2.name}: ${shortDesc}`;
+          }).join("\n");
+          defs.push({
+            type: "function",
+            function: {
+              name: "tool_search",
+              description: `Search for and activate additional tools not in your current tool list. Call this when your task needs a tool you don't have. Pass a search query describing what you need.
+
+Available tools (${deferred.length}):
+${catalog}`,
+              parameters: {
+                type: "object",
+                properties: {
+                  query: { type: "string", description: "Search query (tool name or capability description)" }
+                },
+                required: ["query"]
+              }
+            }
+          });
+          if (!this.tools.has("tool_search")) {
+            this.tools.set("tool_search", {
+              name: "tool_search",
+              description: "Search for deferred tools",
+              parameters: {},
+              execute: async (args) => {
+                const query = String(args["query"] ?? "").toLowerCase();
+                const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || t2.description.toLowerCase().includes(query)).slice(0, 5);
+                if (matches.length === 0) {
+                  return { success: false, output: "", error: `No tools matching "${query}". Try a broader search.` };
+                }
+                const result = matches.map((t2) => {
+                  const paramsStr = JSON.stringify(t2.parameters, null, 2);
+                  return `## ${t2.name}
+${t2.description}
+
+Parameters:
+${paramsStr}`;
+                }).join("\n\n---\n\n");
+                return {
+                  success: true,
+                  output: `Found ${matches.length} tool(s). You can now call them directly:
+
+${result}`
+                };
+              }
+            });
+          }
+        }
+        this.emit({
+          type: "status",
+          content: `Tool deferral: ${dedupedInline.length} inline + ${deferred.length} deferred (${tier} tier)`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return defs;
       }
       // -------------------------------------------------------------------------
       // Transient error recovery — retry on 502, fetch failed, timeouts

package/package.json

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

package/prompts/agentic/system-medium.md

@@ -103,6 +103,8 @@ When asked "how do you work?" or "what can you do?", answer from this list and u
 
 The <environment> block contains LIVE hardware metrics updated every turn. When asked about system specs, hardware, battery, CPU, RAM, GPU, disk space, or processes — read and report those values directly. You CAN see them.
 
+When working with tool results, write down any important information you might need later in your response, as older tool results may be cleared to save context space.
+
 ## Calculations — Always Execute, Never Guess
 
 For ANY numerical calculation involving 2+ operations, write Python and execute it with `repl_exec` or `shell`. In-head arithmetic is error-prone across all model sizes. Python is exact.

package/prompts/agentic/system-small.md

@@ -33,6 +33,8 @@ Rules:
 - When asked "what can you do?", use explore_tools() and skill_list() to discover and report your actual capabilities. Do NOT hallucinate.
 - The <environment> block contains LIVE system metrics. When asked about hardware, battery, CPU, RAM, GPU, disk, or system info — read and report those values directly.
 
+When working with tool results, write down any important information you might need later in your response, as older tool results may be cleared to save context space.
+
 Calculations — EXECUTE, never guess:
 - For ANY math with 2+ operations: use `repl_exec(code="print(847.50 * 0.15)")` or `shell`. Python is exact. In-head arithmetic is not.
 - Currency, percentages, statistics, dates — ALWAYS execute code. If execution fails, reason step-by-step and mark [ESTIMATED].