openmausbot 0.1.96 → 0.1.97

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

@@ -10,6 +10,7 @@ import { createChatToolApproval } from "./chat-tool-approval.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";
+import { classifyContinuable, writeTurnHandoff } from "../turn-continuation.js";
 /** The message of a JSON error body a provider returned with HTTP 200.
  *  MiniMax reports auth, balance, and parameter failures as `base_resp`. */
 function providerError(json) {
@@ -87,6 +88,53 @@ function rejectsReasoningReplay(status, body) {
     return typeof message === "string" && /\breasoning_content\b/.test(message) &&
         /\b(?:unsupported|not supported|unknown|unrecognized|unexpected|not permitted|not allowed)\b/i.test(message);
 }
+/** Groq checks each generated tool call against the request and fails the
+ *  completion with `tool_use_failed` when the call is invalid: most often a
+ *  tool it was not offered (gpt-oss inventing a "json" tool to answer in
+ *  JSON), sometimes arguments that miss the schema. `refusal` is the
+ *  provider's whole error object, `failed_generation` included. */
+class RejectedToolCallError extends ChatProtocolError {
+    refusal;
+    constructor(message, refusal) {
+        super(message);
+        this.refusal = refusal;
+    }
+}
+const toolCallRefusal = (error) => {
+    const body = object(error);
+    return body?.code === "tool_use_failed" ? body : undefined;
+};
+function refusedToolCall(status, body) {
+    if (status !== 400)
+        return undefined;
+    try {
+        return toolCallRefusal(object(JSON.parse(body))?.error);
+    }
+    catch {
+        return undefined;
+    }
+}
+function completionError(json, label) {
+    const message = providerError(json);
+    if (!message)
+        return null;
+    const text = `provider returned a ${label}: ${message.slice(0, 200)}`;
+    const refusal = toolCallRefusal(json.error);
+    return refusal ? new RejectedToolCallError(text, refusal) : new ChatProtocolError(text);
+}
+/** What a failed turn says once the provider refused every attempt: what
+ *  happened, the next step, then the provider's words. The refused call ran
+ *  nothing, but tool calls from earlier steps of the turn did, and a Retry
+ *  of the whole request would repeat them. */
+function refusedToolCallFailure(error, earlierSteps) {
+    const words = typeof error.refusal.message === "string" ? error.refusal.message : error.message;
+    const tool = /attempted to call tool '([^']+)'/.exec(words)?.[1];
+    const what = tool ? `tried to use a tool it was not given ("${tool}")` : "made a tool call the provider rejected";
+    const next = earlierSteps
+        ? "The steps before it already ran, so ask only for what's left."
+        : "Nothing ran. Retry; if it keeps happening, rephrase the request or choose another model.";
+    return `The model ${what}. ${next} Provider: ${words.slice(0, 200)}`;
+}
 /** Shared runtime for the three providers that speak OpenAI chat completions. */
 export function createOpenAIChatRuntime(options) {
     const { input } = options;
@@ -137,6 +185,9 @@ export function createOpenAIChatRuntime(options) {
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
+                const refusal = refusedToolCall(response.status, body);
+                if (refusal)
+                    throw new RejectedToolCallError(message, refusal);
                 if (messages.some((entry) => entry.reasoning_content !== undefined) && rejectsReasoningReplay(response.status, body)) {
                     throw new UnsupportedReasoningReplayError(message);
                 }
@@ -155,9 +206,9 @@ export function createOpenAIChatRuntime(options) {
                         costUsd: count(json.usage?.cost),
                     });
                 }
-                const bodyError = providerError(json);
+                const bodyError = completionError(json, "completion error");
                 if (bodyError)
-                    throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                    throw bodyError;
                 const message = json.choices?.[0]?.message;
                 if (!message || !object(message) || !["content", "reasoning_content", "reasoning", "reasoning_details", "tool_calls", "function_call"].some((key) => key in message)) {
                     throw new ChatProtocolError("provider returned no completion message");
@@ -219,9 +270,9 @@ export function createOpenAIChatRuntime(options) {
                         malformedFrame = true;
                     return false;
                 }
-                const chunkError = providerError(chunk);
+                const chunkError = completionError(chunk, "streaming completion error");
                 if (chunkError)
-                    throw new ChatProtocolError(`provider returned a streaming completion error: ${chunkError.slice(0, 200)}`);
+                    throw chunkError;
                 const choice = chunk.choices?.find((row) => row.index === undefined || row.index === 0);
                 const delta = choice?.delta;
                 if (object(delta))
@@ -271,9 +322,9 @@ export function createOpenAIChatRuntime(options) {
                             catch {
                                 body = undefined;
                             }
-                            const bodyError = body ? providerError(body) : null;
+                            const bodyError = body ? completionError(body, "completion error") : null;
                             if (bodyError)
-                                throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                                throw bodyError;
                         }
                         throw new ChatProtocolError("Stream ended before completion");
                     }
@@ -436,6 +487,7 @@ export function createOpenAIChatRuntime(options) {
                     let completion;
                     for (;;) {
                         let streamed = false;
+                        let answerStreamed = false;
                         const pending = { assistant_text: "", reasoning_text: "" };
                         const delta = (text, streamKind, flush = false) => {
                             let combined = pending[streamKind] + text;
@@ -464,6 +516,8 @@ export function createOpenAIChatRuntime(options) {
                         try {
                             completion = await complete(messages, model, true, abort.signal, (text, streamKind) => {
                                 streamed = true;
+                                if (streamKind === "assistant_text")
+                                    answerStreamed = true;
                                 delta(text, streamKind);
                             }, tools.definitions);
                             delta("", "assistant_text", true);
@@ -483,6 +537,20 @@ export function createOpenAIChatRuntime(options) {
                                     delete message.reasoning_content;
                                 continue;
                             }
+                            // A refused tool call ran nothing, so the same request goes
+                            // again; the model usually answers properly next time. Not once
+                            // answer text streamed: the phones' live bubble would join it to
+                            // the next attempt's. Streamed thinking stays thinking. Each
+                            // refusal, failed_generation included, goes to the native log.
+                            if (error instanceof RejectedToolCallError) {
+                                native("in", { refused: "tool_use_failed", attempt: attempt + 1, error: error.refusal });
+                                if (!answerStreamed && !abort.signal.aborted && attempt < RETRY_MAX_ATTEMPTS - 1) {
+                                    emit({ ...base(turn.threadId, turnId), type: "turn.retrying", attempt: ++attempt, delayMs: 0, reason: "tool_use_failed" });
+                                    continue;
+                                }
+                                if (!abort.signal.aborted)
+                                    throw new ChatProtocolError(refusedToolCallFailure(error, seenCalls.size > 0));
+                            }
                             // Only our optional question changed a previously plain request.
                             // A structured parameter rejection has executed nothing; never
                             // downgrade mounted tools, streamed output or a handled call.
@@ -526,6 +594,9 @@ export function createOpenAIChatRuntime(options) {
                             continue;
                         }
                         if (toolFailed) {
+                            // A failed or denied tool op ends the turn: the final answer is
+                            // not an execution receipt, and a person's "no" must never be
+                            // answered with a prompt to run the same thing again.
                             stopReason = "tool_error";
                             throw new ChatProtocolError("One or more tool operations failed or were denied. See the tool results; the final response is not an execution receipt.");
                         }
@@ -680,6 +751,27 @@ export function createOpenAIChatRuntime(options) {
                 if (failure && (!abort.signal.aborted || cleanupFailed)) {
                     emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: failure, terminal: !abort.signal.aborted });
                 }
+                // Automatic continuity: a resumable terminal (budget cap or tool
+                // errors) persists a handoff and raises cap.exhausted so the harness
+                // can start a `Continue:` thread. Interruptions and provider config
+                // errors are excluded by classifyContinuable.
+                if (!ok && !abort.signal.aborted) {
+                    const continuable = classifyContinuable(stopReason, failure);
+                    if (continuable) {
+                        const handoffPath = writeTurnHandoff({
+                            threadId: turn.threadId,
+                            turnId,
+                            model,
+                            usage,
+                            hasUsage,
+                            failure,
+                            toolCalls: seenCalls.size,
+                            messages,
+                        });
+                        if (handoffPath)
+                            emit({ ...base(turn.threadId, turnId), type: "cap.exhausted", handoffPath, reason: continuable });
+                    }
+                }
                 active.delete(turn.threadId);
                 emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok, stopReason, cost: null,
                     ...(hasUsage && (options.includeUsageInCompleted || seenCalls.size) ? { usage } : {}),

package/dist-server/server/drivers/pi.js

@@ -40,6 +40,12 @@ const DRIVER_KIND = "piAgent";
 const PI_ARGS = ["--mode", "rpc", "--no-session"];
 const PI_MODEL_UPDATE_ARGS = ["update", "--models", "--no-approve"];
 const NODE_ENV_FLAG = { ELECTRON_RUN_AS_NODE: "1" };
+/** omp's RPC transport caps one frame at 1 MiB and only chunks oversized
+ *  frames after the client negotiates protocol 2. Sent before the first
+ *  command on every spawn: stdin order guarantees the declaration lands
+ *  before the response to that command is encoded, and vanilla pi has no
+ *  handshake frame to wait for, so nobody gates on a reply. */
+const PI_NEGOTIATE_FRAME = { id: "negotiate", type: "negotiate_protocol", protocolVersion: 2 };
 /** After this many bare turns on one pi session the full prompt rides
  * again even without a compaction event: any history rewrite the events
  * miss (an older pi, a missed line) still loses at most this many turns
@@ -135,12 +141,26 @@ export function buildMcpServers(turn) {
     }
     return Object.keys(servers).length ? servers : null;
 }
+/** One decoded frame → catalog, or null when it is not a successful
+ *  `get_available_models` response. Every option is `custom` (pi is BYOK)
+ *  and id is the `provider/modelId` composite the picker and `set_model`
+ *  both use. */
+function piCatalogFromFrame(frame, fallbackDefault) {
+    const res = frame;
+    if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
+        return null;
+    const options = [];
+    for (const m of res.data?.models ?? []) {
+        if (!m?.provider || !m?.id)
+            continue;
+        const id = `${m.provider}/${m.id}`;
+        options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+    }
+    return { default: fallbackDefault || (options[0]?.id ?? ""), options };
+}
 /** Pure parser: turn a `get_available_models` stdout blob into a catalog.
- *  Every option is `custom` (pi is BYOK) and id is the `provider/modelId`
- *  composite the picker and `set_model` both use. Exported for the test. */
+ *  Exported for the test. */
 export function parsePiCatalog(stdout, fallbackDefault = "") {
-    const options = [];
-    let def = fallbackDefault;
     for (const line of stdout.split("\n")) {
         if (!line.trim())
             continue;
@@ -151,20 +171,142 @@ export function parsePiCatalog(stdout, fallbackDefault = "") {
         catch {
             continue;
         }
-        const res = msg;
-        if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
-            continue;
-        for (const m of res.data?.models ?? []) {
-            if (!m?.provider || !m?.id)
-                continue;
-            const id = `${m.provider}/${m.id}`;
-            options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+        const catalog = piCatalogFromFrame(msg, fallbackDefault);
+        if (catalog)
+            return catalog;
+    }
+    return { default: fallbackDefault, options: [] };
+}
+/** omp's RPC v2 splits any frame larger than 1 MiB into base64 `rpc_chunk`
+ *  pieces: one `chunkId`/`count`/`byteLength` for the whole frame, a
+ *  sequential `index`, and `data` carrying one piece. Reassembles one
+ *  logical frame at a time; any inconsistency drops the partial sequence so
+ *  a corrupt stream can never feed a half-built frame to the parser.
+ *  Exported for the test. */
+export class PiRpcChunks {
+    /** omp's advertised cap on one reassembled frame. */
+    static MAX_BYTES = 64 * 1024 * 1024;
+    /** omp's cap on one decoded piece, which also bounds the piece count. */
+    static MAX_PIECE_BYTES = 256 * 1024;
+    static MAX_COUNT = PiRpcChunks.MAX_BYTES / PiRpcChunks.MAX_PIECE_BYTES;
+    chunkId = null;
+    count = 0;
+    byteLength = 0;
+    bytes = 0;
+    parts = [];
+    /** Feed one `rpc_chunk`; returns the reassembled frame when the last
+     *  piece arrives, or null while the sequence is incomplete or broken. */
+    accept(message) {
+        const { chunkId, index, count, byteLength, data } = message;
+        if (typeof chunkId !== "string" || chunkId.length === 0 || typeof data !== "string" ||
+            // Bound the base64 before decoding it, so an oversized piece is
+            // rejected without allocating its bytes.
+            data.length === 0 || data.length > Math.ceil(PiRpcChunks.MAX_PIECE_BYTES / 3) * 4 ||
+            !Number.isInteger(index) || !Number.isInteger(count) || !Number.isInteger(byteLength) ||
+            index < 0 || count < 2 || count > PiRpcChunks.MAX_COUNT ||
+            index >= count ||
+            byteLength < 0 || byteLength > PiRpcChunks.MAX_BYTES) {
+            this.reset();
+            return null;
+        }
+        if (chunkId !== this.chunkId) {
+            // A new sequence may only start at index 0; a different chunkId
+            // mid-sequence means the previous one can never complete.
+            if (index !== 0) {
+                this.reset();
+                return null;
+            }
+            this.chunkId = chunkId;
+            this.count = count;
+            this.byteLength = byteLength;
+            this.parts = [];
+            this.bytes = 0;
+        }
+        else if (count !== this.count || byteLength !== this.byteLength) {
+            this.reset();
+            return null;
+        }
+        const part = Buffer.from(data, "base64");
+        // Every piece must carry bytes: an empty one would let a sequence grow
+        // `parts` without ever approaching `byteLength`.
+        if (index !== this.parts.length || part.length === 0 || part.length > PiRpcChunks.MAX_PIECE_BYTES ||
+            this.bytes + part.length > this.byteLength) {
+            this.reset();
+            return null;
+        }
+        this.parts.push(part);
+        this.bytes += part.length;
+        if (this.parts.length < this.count)
+            return null;
+        const complete = this.bytes === this.byteLength;
+        const text = Buffer.concat(this.parts).toString("utf8");
+        this.reset();
+        if (!complete)
+            return null;
+        try {
+            const frame = JSON.parse(text);
+            return frame && typeof frame === "object" && !Array.isArray(frame)
+                ? frame
+                : null;
+        }
+        catch {
+            return null;
         }
-        break;
     }
-    if (!def && options.length)
-        def = options[0].id;
-    return { default: def, options };
+    reset() {
+        this.chunkId = null;
+        this.count = 0;
+        this.byteLength = 0;
+        this.bytes = 0;
+        this.parts = [];
+    }
+}
+/** Decode one pi stdout line: a plain JSON frame, or one piece of an
+ *  `rpc_chunk` sequence (omp's protocol v2) with the reassembled frame
+ *  returned once complete. Non-JSON lines, scalars and broken sequences
+ *  resolve null and are skipped. Exported for the test. */
+export function decodePiFrame(line, chunks) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const frame = parsed;
+    return frame.type === "rpc_chunk" ? chunks.accept(frame) : frame;
+}
+/** Longest stdout line a reader buffers: omp's cap on one whole frame. */
+const PI_MAX_LINE = PiRpcChunks.MAX_BYTES;
+/** Split a pi child's stdout into non-blank lines for `onLine`, which
+ *  returns true to stop reading. A line longer than PI_MAX_LINE is dropped
+ *  through its newline instead of growing the buffer without bound.
+ *  Exported for the test. */
+export function piLineReader(onLine) {
+    let buf = "";
+    let dropping = false;
+    return (chunk) => {
+        buf += chunk;
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (dropping) {
+                dropping = false;
+                continue;
+            }
+            if (line.length > PI_MAX_LINE || !line.trim())
+                continue;
+            if (onLine(line))
+                return;
+        }
+        if (buf.length > PI_MAX_LINE) {
+            buf = "";
+            dropping = true;
+        }
+    };
 }
 /** Split a picker id into pi's `{provider, modelId}`. Accepts both the
  *  native `provider/modelId` composite and a live-host `host::model`
@@ -306,7 +448,6 @@ function readPiDefaultModel(env) {
 export async function fetchPiModels(cli, env) {
     const child = spawnCli(cli, PI_ARGS, { stdio: ["pipe", "pipe", "pipe"], env });
     return new Promise((resolve) => {
-        let buf = "";
         let done = false;
         const fallbackDefault = readPiDefaultModel(env);
         const finish = (catalog) => {
@@ -323,26 +464,20 @@ export async function fetchPiModels(cli, env) {
         };
         const timer = setTimeout(() => finish({ default: "", options: [] }), 15_000);
         timer.unref?.();
+        const chunks = new PiRpcChunks();
         child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            buf += chunk;
-            let nl;
-            while ((nl = buf.indexOf("\n")) !== -1) {
-                const line = buf.slice(0, nl);
-                buf = buf.slice(nl + 1);
-                if (!line.trim())
-                    continue;
-                const parsed = parsePiCatalog(line + "\n", fallbackDefault);
-                if (parsed.options.length || line.includes('"get_available_models"')) {
-                    clearTimeout(timer);
-                    finish(parsed);
-                    return;
-                }
-            }
-        });
+        child.stdout.on("data", piLineReader((line) => {
+            const frame = decodePiFrame(line, chunks);
+            if (frame?.command !== "get_available_models")
+                return false;
+            clearTimeout(timer);
+            finish(piCatalogFromFrame(frame, fallbackDefault) ?? { default: fallbackDefault, options: [] });
+            return true;
+        }));
         child.on("error", () => finish({ default: "", options: [] }));
         child.on("close", () => finish({ default: "", options: [] }));
         try {
+            child.stdin.write(`${JSON.stringify(PI_NEGOTIATE_FRAME)}\n`);
             child.stdin.write(JSON.stringify({ id: "catalog", type: "get_available_models" }) + "\n");
         }
         catch {
@@ -542,7 +677,6 @@ export const PiDriver = {
                     throw err;
                 }
             })();
-            let buf = "";
             let assistantText = "";
             // set when a compaction event arrives this turn; gates the receipt
             // write below so a compacted-around delivery is never claimed
@@ -575,6 +709,11 @@ export const PiDriver = {
                 appendNative(threadId, { dir: "out", source: "pi.rpc", msg: piNativeLogMessage(obj) });
                 child.stdin.write(JSON.stringify(obj) + "\n");
             };
+            // Declare protocol 2 on the same stdin before the first command, so an
+            // omp-style runtime chunks any oversized frame it sends back. Vanilla
+            // pi refuses the unknown command; no waiter is keyed for the reply,
+            // so either answer is ignored.
+            send(PI_NEGOTIATE_FRAME);
             /** Emit buffered assistant text as its own item, then clear it. */
             const flushAssistantText = () => {
                 const text = assistantText;
@@ -911,23 +1050,19 @@ export const PiDriver = {
                         return;
                 }
             };
+            const chunks = new PiRpcChunks();
             child.stdout.setEncoding("utf8");
-            child.stdout.on("data", (chunk) => {
-                buf += chunk;
-                let nl;
-                while ((nl = buf.indexOf("\n")) !== -1) {
-                    const line = buf.slice(0, nl);
-                    buf = buf.slice(nl + 1);
-                    if (!line.trim())
-                        continue;
-                    try {
-                        onEvent(JSON.parse(line));
-                    }
-                    catch {
-                        /* skip non-JSON line */
-                    }
+            child.stdout.on("data", piLineReader((line) => {
+                const frame = decodePiFrame(line, chunks);
+                if (!frame)
+                    return;
+                try {
+                    onEvent(frame);
                 }
-            });
+                catch {
+                    /* skip a frame the event handler can't consume */
+                }
+            }));
             child.on("error", (err) => {
                 const fail = describeSpawnFailure(err, config.cli);
                 rejectWaiters(new Error(fail.message));