openmausbot 0.1.95 → 0.1.96

package/dist-server/server/drivers/openai-chat.js

@@ -7,7 +7,7 @@ import { ChatToolSessionError, mountChatTools } from "./chat-mcp-tools.js";
 import { assertImageTransport, chatImageBudget, chatToolImages, chatUserContent } from "./chat-images.js";
 import { promptHalves, volatileContextNote, withContextNote } from "./prompt-split.js";
 import { createChatToolApproval } from "./chat-tool-approval.js";
-import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, MAX_CHAT_TOOL_CALLS, object } from "./openai-chat-protocol.js";
+import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, object } from "./openai-chat-protocol.js";
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 /** The message of a JSON error body a provider returned with HTTP 200.
@@ -31,6 +31,15 @@ const usageFrom = (usage) => usage
 const asError = (value) => value instanceof Error ? value : new Error(String(value));
 class UnsupportedChatToolsError extends Error {
 }
+/** One turn's safety stops: model steps, and tool calls across all of them.
+ * Tool-heavy models (a memory server, a browser) take dozens of steps, and
+ * a stopped turn cannot simply be continued — the next turn is rebuilt from
+ * the text transcript, which holds none of these tool results. The calls
+ * that ran have taken effect, so the stop asks only for what is left: a
+ * retry of the whole task would repeat them. */
+const MAX_CHAT_ROUNDS = 64;
+const MAX_TURN_TOOL_CALLS = 200;
+const stoppedAfter = (count) => `Stopped after ${count} without a final answer. The steps so far already ran, so ask only for what's left.`;
 const NUDGE_ANNOUNCED_ACTION = "You said what you would do next but called no tool. Do it now with your tools, or reply with your final answer if nothing is left to do.";
 /** A short reply that only announces a next step, with nothing to answer. */
 export function announcesAction(text) {
@@ -413,7 +422,7 @@ export function createOpenAIChatRuntime(options) {
                 if (questionAllowed && !tools.definitions.some((definition) => definition.function.name === ASK_USER_TOOL)) {
                     tools.definitions.push(ASK_USER_TOOL_DEFINITION);
                 }
-                for (let round = 0; round < 16; round++) {
+                for (let round = 0; round < MAX_CHAT_ROUNDS; round++) {
                     abort.signal.throwIfAborted();
                     // Drain parked mid-turn input here, before the next completion
                     // request: the previous round's tool results are complete, so a
@@ -531,8 +540,9 @@ export function createOpenAIChatRuntime(options) {
                             throw new ChatProtocolError("provider reused a tool-call ID; refusing to repeat an operation");
                         seenCalls.add(call.id);
                     }
-                    if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
-                        throw new ChatProtocolError("tool-call limit reached");
+                    // The whole batch is refused before any of it runs.
+                    if (seenCalls.size > MAX_TURN_TOOL_CALLS)
+                        throw new ChatProtocolError(stoppedAfter(`${MAX_TURN_TOOL_CALLS} tool calls`));
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
                         ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { [options.reasoningReplayField ?? "reasoning_content"]: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
@@ -645,7 +655,7 @@ export function createOpenAIChatRuntime(options) {
                         messages.push({ role: "user", content: screenshotParts });
                 }
                 if (!ok)
-                    throw new ChatProtocolError("model-call limit reached before a final response");
+                    throw new ChatProtocolError(stoppedAfter(`${MAX_CHAT_ROUNDS} steps`));
             }
             catch (value) {
                 stopReason = abort.signal.aborted ? "interrupted" : stopReason ?? "error";

package/dist-server/server/drivers/prompt-split.js

@@ -1,9 +1,9 @@
 // The stable/volatile prompt split, shared by the drivers that deliver it.
 // The stable half is everything that must stay byte-identical for a
 // provider's cached prefix (or a spawned CLI's session contract) to
-// survive; the volatile half (memory, mentions, outstanding teammate
-// work, recent work) legitimately changes mid-conversation and reaches
-// the model inside the turn that changed it, after the cacheable prefix.
+// survive; the volatile half (the sections in VOLATILE_SECTIONS,
+// system-prompt.ts) legitimately changes mid-conversation and reaches the
+// model inside the turn that changed it, after the cacheable prefix.
 import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
@@ -20,7 +20,7 @@ export function promptHalves(turn) {
     return { stable: systemStable, volatile: systemVolatile };
 }
 export const VOLATILE_CONTEXT_NOTE_PREFIX = "Context from OpenMausBot updated since this conversation started; it replaces any earlier copy:";
-export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation (memory, mentions, outstanding teammate work) have been cleared; the standing instructions still apply.";
+export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation have been cleared; the standing instructions still apply.";
 /** The labelled block that carries a changed volatile half inside a user
  * turn. A half that is empty and always was needs no note; one that was
  * cleared announces the removal so the model stops relying on it. */

package/dist-server/server/harness/bus.js

@@ -4,6 +4,13 @@
 // a per-thread canonical NDJSON log (the debugging trick both upstream and
 // agentcal lean on), and delivered to subscribers (the SSE endpoint and
 // the server-side message folder).
+//
+// Streamed text is merged here, once, for every engine on every kind of
+// install: a provider sends a reply as hundreds of small text deltas, and
+// each would otherwise be its own log line, listener call and SSE frame. The
+// bus holds a thread's text for at most DELTA_MERGE_MS and publishes it as
+// one delta, sooner when anything else happens on that thread, so the order
+// of events never changes.
 import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { EVENTS_DIR } from "../config.js";
@@ -11,10 +18,19 @@ import { redactSecrets } from "../redact.js";
 import { capThreadLog, currentThreadLogCap } from "../thread-log-rotation.js";
 import { newId } from "../contracts.js";
 const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
+/** How long a thread's streamed text waits to be merged with what follows. */
+const DELTA_MERGE_MS = 50;
+/** Two deltas are one stream when only their text, id and time differ. */
+function sameStream(a, b) {
+    return a.provider === b.provider && a.providerInstanceId === b.providerInstanceId && a.turnId === b.turnId &&
+        a.itemId === b.itemId && a.streamKind === b.streamKind && a.synthetic === b.synthetic;
+}
 export class EventBus {
     listeners = new Set();
     unsubscribes = new Map();
     pendingLogWarnings = new Map();
+    /** Per thread: the streamed text not yet published, and when it goes. */
+    pendingText = new Map();
     appendLog;
     constructor(appendLog = appendFileSync) {
         this.appendLog = appendLog;
@@ -35,6 +51,38 @@ export class EventBus {
         }
     }
     publish(event) {
+        const pending = this.pendingText.get(event.threadId);
+        if (event.type === "content.delta") {
+            if (pending && sameStream(pending.event, event)) {
+                pending.event = { ...pending.event, delta: pending.event.delta + event.delta };
+                return;
+            }
+            if (pending)
+                this.flushThread(event.threadId);
+            const timer = setTimeout(() => this.flushThread(event.threadId), DELTA_MERGE_MS);
+            timer.unref?.();
+            this.pendingText.set(event.threadId, { event, timer });
+            return;
+        }
+        if (pending)
+            this.flushThread(event.threadId);
+        this.write(event);
+    }
+    /** Publish every thread's waiting text now: on detach, and as the server exits. */
+    flush() {
+        for (const threadId of Array.from(this.pendingText.keys()))
+            this.flushThread(threadId);
+    }
+    flushThread(threadId) {
+        const pending = this.pendingText.get(threadId);
+        if (!pending)
+            return;
+        // gone from the map before delivery: a listener may publish on this thread
+        this.pendingText.delete(threadId);
+        clearTimeout(pending.timer);
+        this.write(pending.event);
+    }
+    write(event) {
         const pendingWarning = this.pendingLogWarnings.get(event.threadId);
         const persistedEvents = pendingWarning ? [pendingWarning, redactSecrets(event)] : [redactSecrets(event)];
         try {
@@ -91,5 +139,6 @@ export class EventBus {
     detach(instanceId) {
         this.unsubscribes.get(instanceId)?.();
         this.unsubscribes.delete(instanceId);
+        this.flush();
     }
 }

package/dist-server/server/harness-mcp-proxy.js

@@ -13,7 +13,7 @@ const RECOVERY = {
     browser: " This failure does not establish that all browsers are unavailable. Inspect available connections with select_computer if that tool is present. Keep the requested computer and account; do not bypass a permission refusal or human takeover, and do not repeat an uncertain action without checking its result.",
     computer: " Keep working on the assigned cloud computer only; do not bypass a person's control of it, and take a fresh screenshot before repeating an action whose result is uncertain.",
 };
-export function parseHarnessMcpKind(value) {
+function parseHarnessMcpKind(value) {
     return value === "browser" || value === "computer" ? value : null;
 }
 function failure(id, method, message, code = -32603) {