@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.600

package/dist/heart/streaming.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerParser = void 0;
+exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = exports.SettleStreamer = exports.SettleParser = void 0;
+exports.truncateResponsesFunctionCallOutput = truncateResponsesFunctionCallOutput;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
 exports.streamResponsesApi = streamResponsesApi;
 const runtime_1 = require("../nerves/runtime");
 // Character-level state machine that extracts the answer value from
-// `final_answer` tool call JSON arguments as they stream in.
+// `settle` tool call JSON arguments as they stream in.
 // Scans for prefix `"answer":"` or `"answer": "` in the character stream,
 // then emits text handling JSON escapes, stopping at unescaped closing `"`.
-class FinalAnswerParser {
+class SettleParser {
     // Possible prefixes to match (with and without space after colon)
     static PREFIXES = ['"answer":"', '"answer": "'];
     // Buffer of characters seen so far (pre-activation only)
@@ -29,7 +30,7 @@ class FinalAnswerParser {
             if (!this._active) {
                 this.buf += ch;
                 // Check if any prefix has been fully matched in the buffer
-                for (const prefix of FinalAnswerParser.PREFIXES) {
+                for (const prefix of SettleParser.PREFIXES) {
                     if (this.buf.endsWith(prefix)) {
                         this._active = true;
                         break;
@@ -76,7 +77,106 @@ class FinalAnswerParser {
         return out;
     }
 }
-exports.FinalAnswerParser = FinalAnswerParser;
+exports.SettleParser = SettleParser;
+// Shared helper: wraps SettleParser with onClearText + onTextChunk wiring.
+// Used by all streaming providers (Chat Completions, Responses API, Anthropic)
+// so the eager-match settle streaming pattern lives in one place.
+class SettleStreamer {
+    parser = new SettleParser();
+    _detected = false;
+    callbacks;
+    enabled;
+    constructor(callbacks, enabled = true) {
+        this.callbacks = callbacks;
+        this.enabled = enabled;
+    }
+    get detected() { return this._detected; }
+    get streamed() { return this.parser.active; }
+    /** Mark settle as detected. Calls onClearText on the callbacks. */
+    activate() {
+        if (!this.enabled)
+            return;
+        if (this._detected)
+            return;
+        this._detected = true;
+        this.callbacks.onClearText?.();
+    }
+    /** Feed an argument delta through the parser. Emits text via onTextChunk. */
+    processDelta(delta) {
+        if (!this.enabled)
+            return;
+        if (!this._detected)
+            return;
+        const text = this.parser.process(delta);
+        if (text)
+            this.callbacks.onTextChunk(text);
+    }
+}
+exports.SettleStreamer = SettleStreamer;
+exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = 200_000;
+function truncateResponsesFunctionCallOutput(output, maxChars = exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP) {
+    if (output.length <= maxChars)
+        return output;
+    const marker = `\n\n[truncated — function_call_output exceeded ${maxChars} chars; original length ${output.length} chars]\n\n`;
+    const remainingBudget = Math.max(0, maxChars - marker.length);
+    const headLength = Math.ceil(remainingBudget * 0.75);
+    const tailLength = Math.max(0, remainingBudget - headLength);
+    return `${output.slice(0, headLength)}${marker}${output.slice(-tailLength)}`;
+}
+function toResponsesUserContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = typeof part.image_url?.url === "string" ? part.image_url.url : "";
+            if (!imageUrl)
+                continue;
+            parts.push({
+                type: "input_image",
+                image_url: imageUrl,
+                detail: part.image_url?.detail ?? "auto",
+            });
+            continue;
+        }
+        if (part.type === "input_audio" &&
+            typeof part.input_audio?.data === "string" &&
+            (part.input_audio.format === "mp3" || part.input_audio.format === "wav")) {
+            parts.push({
+                type: "input_audio",
+                input_audio: {
+                    data: part.input_audio.data,
+                    format: part.input_audio.format,
+                },
+            });
+            continue;
+        }
+        if (part.type === "file") {
+            const fileRecord = { type: "input_file" };
+            if (typeof part.file?.file_data === "string")
+                fileRecord.file_data = part.file.file_data;
+            if (typeof part.file?.file_id === "string")
+                fileRecord.file_id = part.file.file_id;
+            if (typeof part.file?.filename === "string")
+                fileRecord.filename = part.file.filename;
+            if (typeof part.file?.file_data === "string" || typeof part.file?.file_id === "string") {
+                parts.push(fileRecord);
+            }
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
 function toResponsesInput(messages) {
     let instructions = "";
     const input = [];
@@ -90,7 +190,7 @@ function toResponsesInput(messages) {
         }
         if (msg.role === "user") {
             const u = msg;
-            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            input.push({ role: "user", content: toResponsesUserContent(u.content) });
             continue;
         }
         if (msg.role === "assistant") {
@@ -102,7 +202,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
@@ -125,7 +228,7 @@ function toResponsesInput(messages) {
             input.push({
                 type: "function_call_output",
                 call_id: t.tool_call_id,
-                output: typeof t.content === "string" ? t.content : "",
+                output: truncateResponsesFunctionCallOutput(typeof t.content === "string" ? t.content : ""),
             });
             continue;
         }
@@ -141,7 +244,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -155,8 +258,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerParser = new FinalAnswerParser();
-    let finalAnswerDetected = false;
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -271,24 +373,21 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     toolCalls[tc.index].id = tc.id;
                 if (tc.function?.name) {
                     toolCalls[tc.index].name = tc.function.name;
-                    // Detect final_answer tool call on first name delta.
+                    // Detect settle tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                    if (tc.function.name === "settle" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
                         && Object.keys(toolCalls).length === 1) {
-                        const text = answerParser.process(tc.function.arguments);
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(tc.function.arguments);
                     }
                 }
             }
@@ -302,10 +401,10 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerParser.active,
+        settleStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -320,9 +419,8 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerParser = new FinalAnswerParser();
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     let functionCallCount = 0;
-    let finalAnswerDetected = false;
     for await (const event of response) {
         if (signal?.aborted)
             break;
@@ -351,12 +449,11 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                         name: String(event.item.name),
                         arguments: "",
                     };
-                    // Detect final_answer function call -- clear any streamed noise.
+                    // Detect settle function call -- clear any streamed noise.
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
-                    if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                    if (String(event.item.name) === "settle" && functionCallCount === 1) {
+                        answerStreamer.activate();
                     }
                 }
                 break;
@@ -364,13 +461,11 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
             case "response.function_call_arguments.delta": {
                 if (currentToolCall) {
                     currentToolCall.arguments += event.delta;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "settle"
                         && functionCallCount === 1) {
-                        const text = answerParser.process(String(event.delta));
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(String(event.delta));
                     }
                 }
                 break;
@@ -410,6 +505,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerParser.active,
+        settleStreamed: answerStreamer.streamed,
     };
 }

package/dist/heart/sync-classification.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Sync failure taxonomy classifier — Layer 2 of the harness-hardening sequence.
+ *
+ * Pure pattern-matcher over (error, context) that turns common git failure
+ * shapes into the locked taxonomy variants. Used by `runBootSyncProbe` (the
+ * `ouro up` pre-flight pull orchestrator) and by `postTurnPush`'s legacy
+ * push-rejected/conflict path so both producers share one vocabulary.
+ *
+ * Pattern priority — most actionable / specific wins:
+ *   1. Abort signal (timeout-soft / timeout-hard) — caller explicitly aborted.
+ *   2. not-found-404 — 404 / "Repository not found": remote endpoint gone.
+ *   3. auth-failed — 401 / 403 / "Authentication failed".
+ *   4. network-down — ENOTFOUND / ECONNREFUSED / "Could not resolve host".
+ *   5. dirty-working-tree — "would be overwritten" / "stash them".
+ *   6. merge-conflict — CONFLICT marker in stderr (also collects file list).
+ *   7. non-fast-forward — "non-fast-forward" / "fetch first".
+ *   8. unknown — fallthrough.
+ *
+ * The classifier never throws and never writes to disk. It calls
+ * `git status --porcelain=v1` only when it has already classified the error
+ * as a merge conflict, to enumerate unmerged paths for the consumer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySyncFailure = classifySyncFailure;
+const child_process_1 = require("child_process");
+/**
+ * Enumerate unmerged paths via `git status --porcelain=v1`. Pulled out as a
+ * pure helper so the classifier can be tested without a live git repo (the
+ * caller mocks `child_process.execFileSync`).
+ *
+ * Mirrors `sync.ts:collectRebaseConflictFiles` — kept as a separate copy here
+ * so this module has zero internal dep on `sync.ts`. The caller of
+ * `classifySyncFailure` doesn't see the duplication; the runtime cost is one
+ * git invocation per merge-conflict classification, same as before.
+ */
+function collectConflictFiles(agentRoot) {
+    try {
+        const output = (0, child_process_1.execFileSync)("git", ["status", "--porcelain=v1"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 5000,
+        }).toString();
+        const files = [];
+        for (const line of output.split("\n")) {
+            // Unmerged paths in porcelain v1 are prefixed with UU/AA/DD/AU/UA/DU/UD.
+            if (/^(UU|AA|DD|AU|UA|DU|UD) /.test(line)) {
+                files.push(line.slice(3).trim());
+            }
+        }
+        return files;
+    }
+    catch {
+        /* v8 ignore next -- defensive: git status failure inside a git repo would require a corrupt repo @preserve */
+        return [];
+    }
+}
+function isAbortError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const candidate = error;
+    if (candidate.name === "AbortError")
+        return true;
+    if (candidate.code === "ABORT_ERR")
+        return true;
+    return false;
+}
+function readMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error === null || error === undefined)
+        return String(error);
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        /* v8 ignore next -- defensive: JSON.stringify only fails on circular/BigInt; real-world git errors don't trigger it @preserve */
+        return String(error);
+    }
+}
+function readErrorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+/**
+ * Classify a sync failure into one of the locked taxonomy variants.
+ *
+ * Pure: never throws, never writes. Calls `git status` only when the error
+ * was already classified as a merge conflict, to enumerate unmerged files.
+ */
+function classifySyncFailure(error, context) {
+    const message = readMessage(error);
+    const errorCode = readErrorCode(error);
+    // 1. Abort signal — highest priority. Caller's signal trumps content match.
+    if (isAbortError(error)) {
+        const reason = context.abortReason ?? "hard";
+        return {
+            classification: reason === "soft" ? "timeout-soft" : "timeout-hard",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // Lowercased copy for case-insensitive substring matching.
+    const lower = message.toLowerCase();
+    // 2. Not-found-404 — most actionable diagnosis when both 404 and other
+    // signals are present. "404" and "Repository not found" are the canonical
+    // shapes.
+    if (lower.includes("404") || lower.includes("repository not found")) {
+        return {
+            classification: "not-found-404",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 3. Auth failed — 401 / 403 / "Authentication failed" / "Permission denied".
+    if (lower.includes("401")
+        || lower.includes("403")
+        || lower.includes("authentication failed")
+        || lower.includes("permission denied")) {
+        return {
+            classification: "auth-failed",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 4. Network down — DNS / connection errors.
+    if (errorCode === "ENOTFOUND"
+        || errorCode === "ECONNREFUSED"
+        || lower.includes("enotfound")
+        || lower.includes("econnrefused")
+        || lower.includes("could not resolve host")
+        || lower.includes("connection refused")) {
+        return {
+            classification: "network-down",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 5. Dirty working tree — pull / merge would clobber uncommitted changes.
+    if (lower.includes("would be overwritten")
+        || lower.includes("commit your changes or stash them")) {
+        return {
+            classification: "dirty-working-tree",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 6. Merge conflict — CONFLICT marker in stderr. Collect unmerged files.
+    if (lower.includes("conflict")) {
+        return {
+            classification: "merge-conflict",
+            error: message,
+            conflictFiles: collectConflictFiles(context.agentRoot),
+        };
+    }
+    // 7. Non-fast-forward — push rejected because remote moved.
+    if (lower.includes("non-fast-forward")
+        || lower.includes("fetch first")
+        || lower.includes("rejected")) {
+        return {
+            classification: "non-fast-forward",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 8. Fallthrough.
+    return {
+        classification: "unknown",
+        error: message,
+        conflictFiles: [],
+    };
+}