open-agents-ai 0.187.11 → 0.187.13

package/dist/index.js

@@ -259789,6 +259789,194 @@ var init_app_state = __esm({
   }
 });
 
+// packages/orchestrator/dist/streaming-executor.js
+var StreamingToolExecutor;
+var init_streaming_executor = __esm({
+  "packages/orchestrator/dist/streaming-executor.js"() {
+    "use strict";
+    init_tool_batching();
+    StreamingToolExecutor = class {
+      tools = /* @__PURE__ */ new Map();
+      insertionOrder = [];
+      config;
+      executeFn = null;
+      constructor(config) {
+        this.config = {
+          maxConcurrent: config?.maxConcurrent ?? 5
+        };
+      }
+      /** Set the tool execution function */
+      setExecutor(fn) {
+        this.executeFn = fn;
+      }
+      /** Number of tools tracked */
+      get size() {
+        return this.tools.size;
+      }
+      /** Whether any tools have been queued */
+      get hasTools() {
+        return this.tools.size > 0;
+      }
+      /**
+       * Queue a new tool call from streaming response.
+       * Called when a tool_use block is first detected in the stream.
+       */
+      queue(id, name10, partialArgs) {
+        if (this.tools.has(id))
+          return;
+        this.tools.set(id, {
+          id,
+          name: name10,
+          args: partialArgs ?? {},
+          state: "queued",
+          concurrencySafe: isConcurrencySafe(name10),
+          finalized: false,
+          queuedAt: Date.now()
+        });
+        this.insertionOrder.push(id);
+      }
+      /**
+       * Finalize a tool call's arguments (stream complete for this tool_use block).
+       * Parses the accumulated JSON args and triggers execution if conditions allow.
+       */
+      finalize(id, args) {
+        const entry = this.tools.get(id);
+        if (!entry)
+          return;
+        entry.args = args;
+        entry.finalized = true;
+        if (entry.state === "queued") {
+          this.processQueue();
+        }
+      }
+      /**
+       * Get all completed tool results that haven't been yielded yet.
+       * Respects ordering: stops at first non-yielded exclusive tool that's still running.
+       * Marks returned entries as "yielded".
+       */
+      drainCompleted() {
+        const results = [];
+        for (const id of this.insertionOrder) {
+          const entry = this.tools.get(id);
+          if (!entry)
+            continue;
+          if (entry.state === "yielded")
+            continue;
+          if ((entry.state === "completed" || entry.state === "failed") && entry.result) {
+            results.push({ id: entry.id, name: entry.name, result: entry.result });
+            entry.state = "yielded";
+          } else if (entry.state === "executing" && !entry.concurrencySafe) {
+            break;
+          }
+        }
+        return results;
+      }
+      /**
+       * Wait for all queued/executing tools to complete.
+       */
+      async waitAll() {
+        this.processQueue();
+        while (true) {
+          const pending = Array.from(this.tools.values()).filter((e2) => e2.state === "queued" || e2.state === "executing");
+          if (pending.length === 0)
+            break;
+          const executing = pending.filter((e2) => e2.promise);
+          if (executing.length > 0) {
+            await Promise.allSettled(executing.map((e2) => e2.promise));
+            this.processQueue();
+          } else {
+            this.processQueue();
+            await new Promise((r2) => setTimeout(r2, 1));
+          }
+        }
+      }
+      /** Get the current state of all tool calls */
+      getStates() {
+        const states = /* @__PURE__ */ new Map();
+        for (const [id, entry] of this.tools) {
+          states.set(id, entry.state);
+        }
+        return states;
+      }
+      /** Get count of tools in each state */
+      getCounts() {
+        const counts = {
+          queued: 0,
+          executing: 0,
+          completed: 0,
+          failed: 0,
+          yielded: 0
+        };
+        for (const entry of this.tools.values()) {
+          counts[entry.state]++;
+        }
+        return counts;
+      }
+      /** Clear all tool entries (call between turns) */
+      reset() {
+        this.tools.clear();
+        this.insertionOrder = [];
+      }
+      // ─────────────────────────────────────────────────────────
+      // Internal — Hannover-aligned concurrency control
+      // ─────────────────────────────────────────────────────────
+      /**
+       * Can this tool start executing now?
+       * Rules (from Hannover StreamingToolExecutor.canExecuteTool):
+       * 1. No tools executing → any tool can start
+       * 2. New tool is concurrent-safe AND all executing are concurrent-safe → start
+       * 3. Otherwise → wait
+       */
+      canExecute(entry) {
+        if (!this.executeFn)
+          return false;
+        if (!entry.finalized)
+          return false;
+        const executing = Array.from(this.tools.values()).filter((e2) => e2.state === "executing");
+        if (executing.length >= this.config.maxConcurrent)
+          return false;
+        if (executing.length === 0)
+          return true;
+        if (entry.concurrencySafe && executing.every((e2) => e2.concurrencySafe))
+          return true;
+        return false;
+      }
+      /**
+       * Process the queue in insertion order.
+       * Starts tools that can execute, stops at first exclusive tool that must wait.
+       */
+      processQueue() {
+        for (const id of this.insertionOrder) {
+          const entry = this.tools.get(id);
+          if (!entry || entry.state !== "queued")
+            continue;
+          if (this.canExecute(entry)) {
+            this.startExecution(entry);
+          } else if (!entry.concurrencySafe) {
+            break;
+          }
+        }
+      }
+      startExecution(entry) {
+        entry.state = "executing";
+        entry.startedAt = Date.now();
+        const exec4 = this.executeFn;
+        entry.promise = exec4(entry.name, entry.args).then((result) => {
+          entry.state = "completed";
+          entry.result = result;
+          entry.completedAt = Date.now();
+          this.processQueue();
+        }).catch((err) => {
+          entry.state = "failed";
+          entry.result = { success: false, output: "", error: String(err) };
+          entry.completedAt = Date.now();
+          this.processQueue();
+        });
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/agenticRunner.js
 function repairJson(raw) {
   if (!raw || typeof raw !== "string")
@@ -259865,6 +260053,7 @@ var init_agenticRunner = __esm({
     init_tool_batching();
     init_hooks();
     init_app_state();
+    init_streaming_executor();
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
     SYSTEM_PROMPT_SMALL = loadPrompt("agentic/system-small.md");
@@ -259884,6 +260073,7 @@ var init_agenticRunner = __esm({
       _skillCompactionStrategy = null;
       _hookManager = new HookManager();
       _appState = createAppState();
+      _streamingExecutor = new StreamingToolExecutor({ maxConcurrent: 5 });
       // -- Task State Tracking (Priority 3) --
       _taskState = {
         goal: "",
@@ -261016,25 +261206,30 @@ Then use file_read on individual FILES inside it.`);
               return { tc, output };
             };
             const rawToolCalls = msg.toolCalls;
-            const batchToolCalls = rawToolCalls.map((tc) => ({
-              name: tc.name,
-              args: tc.arguments,
-              id: tc.id
-            }));
-            const batches = partitionToolCalls(batchToolCalls);
-            for (const batch2 of batches) {
-              if (this.aborted)
-                break;
-              const results = await executeBatch(batch2, async (call) => {
-                const originalTc = rawToolCalls.find((tc) => tc.id === call.id);
-                return executeSingle(originalTc);
-              }, 5);
-              for (const r2 of results) {
-                if (r2) {
-                  messages2.push(this.buildToolMessage(r2.output, r2.tc.id));
-                  if (r2.tc.name === "task_complete") {
+            if (this.options.streamEnabled && this._streamingExecutor.hasTools) {
+              this._streamingExecutor.setExecutor(async (name10, args) => {
+                const matchTc = rawToolCalls.find((tc) => tc.name === name10 && JSON.stringify(tc.arguments) === JSON.stringify(args)) ?? rawToolCalls.find((tc) => tc.name === name10);
+                if (!matchTc)
+                  return { success: false, output: "", error: `Tool ${name10} not found in response` };
+                const r2 = await executeSingle(matchTc);
+                if (!r2)
+                  return { success: false, output: "", error: "aborted" };
+                const isError2 = r2.output.startsWith("Error:");
+                return { success: !isError2, output: r2.output, error: isError2 ? r2.output : void 0 };
+              });
+              await this._streamingExecutor.waitAll();
+              const streamResults = this._streamingExecutor.drainCompleted();
+              const handledIds = /* @__PURE__ */ new Set();
+              for (const sr of streamResults) {
+                const matchTc = rawToolCalls.find((tc) => tc.id === sr.id) ?? rawToolCalls.find((tc) => tc.name === sr.name && !handledIds.has(tc.id));
+                if (matchTc) {
+                  handledIds.add(matchTc.id);
+                  const output = sr.result.success ? sr.result.output : `Error: ${sr.result.error || "unknown"}
+${sr.result.output}`;
+                  messages2.push(this.buildToolMessage(output, matchTc.id));
+                  if (matchTc.name === "task_complete") {
                     completed = true;
-                    summary = r2.tc.arguments.summary || "";
+                    summary = matchTc.arguments.summary || "";
                     if (summary && !this._assistantTextEmitted) {
                       this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                       this._assistantTextEmitted = true;
@@ -261043,8 +261238,57 @@ Then use file_read on individual FILES inside it.`);
                   }
                 }
               }
-              if (completed)
-                break;
+              if (!completed) {
+                const unhandled = rawToolCalls.filter((tc) => !handledIds.has(tc.id));
+                for (const tc of unhandled) {
+                  if (this.aborted)
+                    break;
+                  const r2 = await executeSingle(tc);
+                  if (r2) {
+                    messages2.push(this.buildToolMessage(r2.output, r2.tc.id));
+                    if (r2.tc.name === "task_complete") {
+                      completed = true;
+                      summary = r2.tc.arguments.summary || "";
+                      if (summary && !this._assistantTextEmitted) {
+                        this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                        this._assistantTextEmitted = true;
+                      }
+                      break;
+                    }
+                  }
+                }
+              }
+            } else {
+              const batchToolCalls = rawToolCalls.map((tc) => ({
+                name: tc.name,
+                args: tc.arguments,
+                id: tc.id
+              }));
+              const batches = partitionToolCalls(batchToolCalls);
+              for (const batch2 of batches) {
+                if (this.aborted)
+                  break;
+                const results = await executeBatch(batch2, async (call) => {
+                  const originalTc = rawToolCalls.find((tc) => tc.id === call.id);
+                  return executeSingle(originalTc);
+                }, 5);
+                for (const r2 of results) {
+                  if (r2) {
+                    messages2.push(this.buildToolMessage(r2.output, r2.tc.id));
+                    if (r2.tc.name === "task_complete") {
+                      completed = true;
+                      summary = r2.tc.arguments.summary || "";
+                      if (summary && !this._assistantTextEmitted) {
+                        this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                        this._assistantTextEmitted = true;
+                      }
+                      break;
+                    }
+                  }
+                }
+                if (completed)
+                  break;
+              }
             }
             if (completed)
               break;
@@ -262963,6 +263207,8 @@ ${description}`
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         let streamUsage;
         this.emit({ type: "stream_start", turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        this._streamingExecutor.reset();
+        let lastFinalizedIdx = -1;
         for await (const chunk of backend.chatCompletionStream(request)) {
           if (this.aborted)
             break;
@@ -263014,21 +263260,52 @@ ${description}`
           }
           if (chunk.type === "tool_call_delta") {
             const idx = chunk.toolCallIndex ?? 0;
+            if (idx > lastFinalizedIdx && lastFinalizedIdx >= 0) {
+              const prevAcc = toolCallAccumulators.get(lastFinalizedIdx);
+              if (prevAcc && prevAcc.name) {
+                let parsedArgs;
+                try {
+                  parsedArgs = JSON.parse(prevAcc.args);
+                } catch {
+                  parsedArgs = repairJson(prevAcc.args) ?? { _raw: prevAcc.args };
+                }
+                this._streamingExecutor.finalize(prevAcc.id, parsedArgs);
+              }
+            }
             if (!toolCallAccumulators.has(idx)) {
-              toolCallAccumulators.set(idx, {
-                id: chunk.toolCallId ?? crypto.randomUUID(),
-                name: chunk.toolCallName ?? "",
-                args: ""
-              });
+              const newId = chunk.toolCallId ?? crypto.randomUUID();
+              const newName = chunk.toolCallName ?? "";
+              toolCallAccumulators.set(idx, { id: newId, name: newName, args: "" });
+              if (newName) {
+                this._streamingExecutor.queue(newId, newName);
+              }
             }
             const acc = toolCallAccumulators.get(idx);
-            if (chunk.toolCallName)
+            if (chunk.toolCallName) {
               acc.name = chunk.toolCallName;
+              if (!this._streamingExecutor.getStates().has(acc.id) && acc.name) {
+                this._streamingExecutor.queue(acc.id, acc.name);
+              }
+            }
             if (chunk.toolCallId)
               acc.id = chunk.toolCallId;
             if (chunk.toolCallArgs) {
               acc.args += chunk.toolCallArgs;
             }
+            lastFinalizedIdx = idx;
+          }
+        }
+        if (toolCallAccumulators.size > 0) {
+          for (const [, acc] of toolCallAccumulators) {
+            if (acc.name && !["completed", "failed", "yielded", "executing"].includes(this._streamingExecutor.getStates().get(acc.id) ?? "")) {
+              let parsedArgs;
+              try {
+                parsedArgs = JSON.parse(acc.args || "{}");
+              } catch {
+                parsedArgs = repairJson(acc.args) ?? { _raw: acc.args };
+              }
+              this._streamingExecutor.finalize(acc.id, parsedArgs);
+            }
           }
         }
         this.emit({ type: "stream_end", content, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -265126,13 +265403,6 @@ var init_skill_fork = __esm({
   }
 });
 
-// packages/orchestrator/dist/streaming-executor.js
-var init_streaming_executor = __esm({
-  "packages/orchestrator/dist/streaming-executor.js"() {
-    "use strict";
-  }
-});
-
 // packages/orchestrator/dist/index.js
 var init_dist7 = __esm({
   "packages/orchestrator/dist/index.js"() {

package/package.json

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