@mclean-capital/neura 3.6.0 → 3.6.1

package/core/server.bundled.mjs

@@ -80568,16 +80568,16 @@ ${context}
         this.turnAudioChunks = 0;
         this.turnAudioBytes = 0;
         this.cb.onTurnComplete();
-        const outputItems = msg.response?.output;
+        const res = msg.response;
+        const outputItems = Array.isArray(res?.output) ? res.output : [];
         const fullParts = [];
-        if (Array.isArray(outputItems)) {
-          for (const item of outputItems) {
-            if (item.type === "message" && Array.isArray(item.content)) {
-              for (const part of item.content) {
-                if (part.transcript) {
-                  this.pushTranscript("assistant", part.transcript);
-                  fullParts.push(part.transcript);
-                }
+        for (const item of outputItems) {
+          const it = item;
+          if (it.type === "message" && Array.isArray(it.content)) {
+            for (const part of it.content) {
+              if (part.transcript) {
+                this.pushTranscript("assistant", part.transcript);
+                fullParts.push(part.transcript);
               }
             }
           }
@@ -80585,53 +80585,85 @@ ${context}
         if (fullParts.length > 0) {
           this.cb.onOutputTranscriptComplete(fullParts.join(""));
         }
+        if (res?.status === "completed") {
+          void this.dispatchFunctionCalls(outputItems);
+        }
         break;
       }
-      case "response.function_call_arguments.done":
-        void this.handleFunctionCallDone(msg);
-        break;
       case "error":
         log32.error("api error", { error: msg.error });
         this.cb.onError(msg.error?.message || "Unknown error");
         break;
     }
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async handleFunctionCallDone(msg) {
-    const name = msg.name ?? "";
-    let args = {};
-    try {
-      args = JSON.parse(msg.arguments ?? "{}");
-    } catch {
-    }
-    const currentWs = this.ws;
-    const callId = msg.call_id;
-    this.cb.onToolCall(name, args);
-    const result = await handleToolCall(name, args, {
-      queryWatcher: this.cb.queryWatcher,
-      memoryTools: this.config.memoryTools,
-      enterMode: this.config.enterMode,
-      taskTools: this.config.taskTools,
-      skillTools: this.config.skillTools,
-      workerControl: this.config.workerControl,
-      workerDispatch: this.config.workerDispatch,
-      systemState: this.config.systemState,
-      workerLogs: this.config.workerLogs
+  /**
+   * Execute every `function_call` item from a completed `response.done`
+   * payload in parallel, post their outputs in original `output_index`
+   * order, then fire exactly one `response.create` so the model sees the
+   * full batch as a single follow-up turn.
+   *
+   * Authoritative source: `response.output`. We intentionally do NOT
+   * buffer `response.function_call_arguments.done` deltas; `response.done`
+   * carries the finalized list and is the only shape we trust — see the
+   * Codex review cited in the corresponding commit.
+   */
+  async dispatchFunctionCalls(outputItems) {
+    const calls = [];
+    outputItems.forEach((item, idx) => {
+      const it = item;
+      if (it.type !== "function_call" || !it.call_id || typeof it.name !== "string") return;
+      let parsed = {};
+      try {
+        parsed = JSON.parse(it.arguments ?? "{}");
+      } catch {
+      }
+      calls.push({ callId: it.call_id, name: it.name, args: parsed, outputIndex: idx });
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const unique = calls.filter((c) => {
+      if (seen.has(c.callId)) return false;
+      seen.add(c.callId);
+      return true;
     });
-    this.cb.onToolResult(name, result);
-    if (currentWs && currentWs === this.ws && currentWs.readyState === wrapper_default.OPEN) {
+    if (unique.length === 0) return;
+    const currentWs = this.ws;
+    const outcomes = [];
+    for (const c of unique) {
+      this.cb.onToolCall(c.name, c.args);
+      try {
+        const result = await handleToolCall(c.name, c.args, {
+          queryWatcher: this.cb.queryWatcher,
+          memoryTools: this.config.memoryTools,
+          enterMode: this.config.enterMode,
+          taskTools: this.config.taskTools,
+          skillTools: this.config.skillTools,
+          workerControl: this.config.workerControl,
+          workerDispatch: this.config.workerDispatch,
+          systemState: this.config.systemState,
+          workerLogs: this.config.workerLogs
+        });
+        this.cb.onToolResult(c.name, result);
+        outcomes.push({ callId: c.callId, result, outputIndex: c.outputIndex });
+      } catch (err) {
+        const errorResult = { error: `Tool ${c.name} failed: ${String(err)}` };
+        this.cb.onToolResult(c.name, errorResult);
+        outcomes.push({ callId: c.callId, result: errorResult, outputIndex: c.outputIndex });
+      }
+    }
+    if (!currentWs || currentWs !== this.ws || currentWs.readyState !== wrapper_default.OPEN) return;
+    outcomes.sort((a, b) => a.outputIndex - b.outputIndex).forEach((o) => {
       currentWs.send(
         JSON.stringify({
           type: "conversation.item.create",
           item: {
             type: "function_call_output",
-            call_id: callId,
-            output: JSON.stringify(result)
+            call_id: o.callId,
+            output: JSON.stringify(o.result)
           }
         })
       );
-      currentWs.send(JSON.stringify({ type: "response.create" }));
-    }
+    });
+    currentWs.send(JSON.stringify({ type: "response.create" }));
   }
   sendAudio(base643) {
     if (this.ws?.readyState === wrapper_default.OPEN) {