@mjasnikovs/pi-task 0.13.9 → 0.13.11

package/dist/shared/child-process.d.ts

@@ -21,6 +21,14 @@ export interface ChildResult {
     aborted: boolean;
     /** Extracted assistant text (only populated in json-events mode). */
     text?: string;
+    /**
+     * The model-failure cause, when the child's final turn carried
+     * stopReason "error" (provider/connection failure after pi exhausted its
+     * own retries). pi emits this as an agent_end whose assistant message has
+     * empty text, so without it the phase would mis-report "produced no output".
+     * Only populated in json-events mode.
+     */
+    modelError?: string;
 }
 export interface ToolCall {
     name: string;
@@ -74,6 +82,13 @@ export declare class JsonEventSink {
     private readonly onLoopKill;
     /** Final assistant text from the agent_end event, if one arrived. */
     finalText: string;
+    /**
+     * Set when the final assistant turn carried stopReason "error" — i.e. the
+     * model/provider failed (disconnect, fetch failed, socket hang up, 5xx)
+     * after pi exhausted its internal retries. Holds the provider's errorMessage
+     * so callers can report the real cause instead of an empty completion.
+     */
+    modelError: string | undefined;
     private textDeltaAccum;
     private buf;
     constructor(opts: RunChildJsonEventsOptions, 

package/dist/shared/child-process.js

@@ -24,6 +24,13 @@ export class JsonEventSink {
     onLoopKill;
     /** Final assistant text from the agent_end event, if one arrived. */
     finalText = '';
+    /**
+     * Set when the final assistant turn carried stopReason "error" — i.e. the
+     * model/provider failed (disconnect, fetch failed, socket hang up, 5xx)
+     * after pi exhausted its internal retries. Holds the provider's errorMessage
+     * so callers can report the real cause instead of an empty completion.
+     */
+    modelError = undefined;
     textDeltaAccum = '';
     // json-events lines can split across data chunks; this holds the trailing
     // partial line between feeds so events spanning a boundary still parse. We
@@ -97,7 +104,20 @@ export class JsonEventSink {
         if (t === 'agent_end' && Array.isArray(evt.messages)) {
             for (let i = evt.messages.length - 1; i >= 0; i--) {
                 const m = evt.messages[i];
-                if (m && m.role === 'assistant' && Array.isArray(m.content)) {
+                if (!m || m.role !== 'assistant')
+                    continue;
+                // A model failure (disconnect, fetch failed, socket hang up, 5xx
+                // after pi's own retries) arrives as an assistant message with
+                // stopReason "error" and the real cause in errorMessage — but
+                // EMPTY text content. Capture it so the phase reports the actual
+                // failure instead of the useless "produced no output".
+                if (m.stopReason === 'error'
+                    && typeof m.errorMessage === 'string'
+                    && m.errorMessage.length > 0
+                    && this.modelError === undefined) {
+                    this.modelError = m.errorMessage;
+                }
+                if (Array.isArray(m.content)) {
                     const texts = [];
                     for (const c of m.content) {
                         if (c?.type === 'text' && typeof c.text === 'string') {
@@ -186,7 +206,14 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             if (sink)
                 sink.flush();
             const text = sink ? sink.text : undefined;
-            resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? 0,
+                aborted,
+                text,
+                modelError: sink?.modelError
+            });
         });
         proc.on('error', () => {
             resolve({ stdout, stderr, exitCode: 1, aborted });

package/dist/task/child-runner.d.ts

@@ -16,6 +16,8 @@ export interface PhaseRunResult {
     loopHit?: LoopHit;
     /** Set when the assistant text contains an unexecuted, leaked tool call. */
     leakedToolCall?: string;
+    /** Set when the child's final turn failed with stopReason "error" (model/provider failure). */
+    modelError?: string;
 }
 export declare function childArgs(tools: string, prompt: string): string[];
 export declare const USER_CANCELLED = "__user_cancelled__";
@@ -74,6 +76,22 @@ export declare class LoopExhaustedError extends Error {
     readonly history: LoopHit[];
     constructor(phase: string, history: LoopHit[]);
 }
+/**
+ * Thrown when a phase child's final turn failed with stopReason "error" — the
+ * model/provider died (local model disconnect, fetch failed, socket hang up,
+ * provider 5xx) after pi exhausted its own internal retries. pi reports this as
+ * an agent_end with empty assistant text, which would otherwise surface as the
+ * misleading "produced no output"; this names the real cause instead.
+ *
+ * Fail-fast: not retried at the pi-task layer. pi already retried the retryable
+ * cases; re-spawning a fresh child against the same dead endpoint only burns
+ * time and buries the real error. Restart the model/provider, then resume.
+ */
+export declare class ModelError extends Error {
+    readonly phase: string;
+    readonly cause: string;
+    constructor(phase: string, cause: string);
+}
 /**
  * Thrown when a phase child repeatedly wrote a tool call as plain text (a markup
  * dialect pi's harness didn't parse) instead of invoking it. The call never ran,

package/dist/task/child-runner.js

@@ -69,6 +69,7 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
         exitCode: result.exitCode,
         stderr: result.stderr.trim(),
         loopHit,
+        modelError: result.modelError,
         // A tool call the model wrote as text (wrong dialect) never executed and
         // sailed past the structured-event guards above; flag it so the wrappers
         // can re-prompt instead of accepting the unexecuted call. Only meaningful
@@ -90,8 +91,21 @@ export async function runPhaseChild(deps, name, tools, prompt) {
         if (r.exitCode !== 0) {
             throw new Error(`${name} child failed: ${r.stderr || '(no stderr)'}`);
         }
+        if (r.modelError) {
+            // The model/provider failed (pi exited 0 with an stopReason "error"
+            // turn). Surface the real cause and fail fast — pi already retried.
+            throw new ModelError(name, r.modelError);
+        }
         if (r.text.trim().length === 0) {
-            throw new Error(`${name} child produced no output${r.stderr ? ' — stderr: ' + r.stderr : ''}`);
+            // An empty completion (exit 0, no assistant text, no stderr) is almost
+            // always transient — a model/API error swallowed inside --mode json,
+            // not a repeatable mistake — so re-spawn rather than fail the phase.
+            // There's nothing to correct, so we carry no hint. Reuses the leak
+            // retry budget: MAX_LEAK_RETRIES+1 attempts, then surface the error.
+            if (attempt === MAX_LEAK_RETRIES) {
+                throw new Error(`${name} child produced no output${r.stderr ? ' — stderr: ' + r.stderr : ''}`);
+            }
+            continue;
         }
         if (r.leakedToolCall) {
             if (attempt === MAX_LEAK_RETRIES) {
@@ -153,8 +167,21 @@ export async function runPhaseWithLoopGuard(deps, name, tools, buildPrompt) {
         if (r.exitCode !== 0) {
             throw new Error(`${name} child failed: ${r.stderr || '(no stderr)'}`);
         }
+        if (r.modelError) {
+            // The model/provider failed (pi exited 0 with a stopReason "error"
+            // turn). Surface the real cause and fail fast — pi already retried.
+            throw new ModelError(name, r.modelError);
+        }
         if (r.text.trim().length === 0) {
-            throw new Error(`${name} child produced no output${r.stderr ? ' — stderr: ' + r.stderr : ''}`);
+            // An empty completion (exit 0, no assistant text, no stderr) is almost
+            // always transient — a model/API error swallowed inside --mode json,
+            // not a repeatable mistake — so re-spawn rather than fail the phase.
+            // Nothing to correct, so leave nextHint as-is. Reuses the strike
+            // budget shared with loop/leak restarts: MAX_LOOP_RESTARTS+1 attempts.
+            if (strike === MAX_LOOP_RESTARTS) {
+                throw new Error(`${name} child produced no output${r.stderr ? ' — stderr: ' + r.stderr : ''}`);
+            }
+            continue;
         }
         if (r.leakedToolCall) {
             if (strike === MAX_LOOP_RESTARTS) {
@@ -194,6 +221,28 @@ export class LoopExhaustedError extends Error {
         this.name = 'LoopExhaustedError';
     }
 }
+// ─── ModelError ──────────────────────────────────────────────────────────────
+/**
+ * Thrown when a phase child's final turn failed with stopReason "error" — the
+ * model/provider died (local model disconnect, fetch failed, socket hang up,
+ * provider 5xx) after pi exhausted its own internal retries. pi reports this as
+ * an agent_end with empty assistant text, which would otherwise surface as the
+ * misleading "produced no output"; this names the real cause instead.
+ *
+ * Fail-fast: not retried at the pi-task layer. pi already retried the retryable
+ * cases; re-spawning a fresh child against the same dead endpoint only burns
+ * time and buries the real error. Restart the model/provider, then resume.
+ */
+export class ModelError extends Error {
+    phase;
+    cause;
+    constructor(phase, cause) {
+        super(`${phase} child: model error — ${cause}`);
+        this.phase = phase;
+        this.cause = cause;
+        this.name = 'ModelError';
+    }
+}
 // ─── LeakedToolCallError ─────────────────────────────────────────────────────
 /**
  * Thrown when a phase child repeatedly wrote a tool call as plain text (a markup

package/dist/task/failure-classifier.js

@@ -4,7 +4,7 @@
  */
 import { updateTaskFrontMatter } from './task-io.js';
 import { flashTerminalWidget } from './widget.js';
-import { LoopExhaustedError, LeakedToolCallError, USER_CANCELLED } from './child-runner.js';
+import { LoopExhaustedError, LeakedToolCallError, ModelError, USER_CANCELLED } from './child-runner.js';
 // ─── Classifier ──────────────────────────────────────────────────────────────
 export function classifyFailure(err, aborted) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -29,6 +29,15 @@ export function classifyFailure(err, aborted) {
             level: 'error'
         };
     }
+    if (err instanceof ModelError) {
+        return {
+            state: 'failed',
+            reason: `model_error in ${err.phase}: ${err.cause.slice(0, 160)}`,
+            flash: 'model_error',
+            notify: `failed: ${err.phase} — model error: ${err.cause.slice(0, 120)}. Restart the model, then resume.`,
+            level: 'error'
+        };
+    }
     if (msg === 'no_verify_block') {
         return {
             state: 'failed',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.9",
+    "version": "0.13.11",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",