fix(cli): fail headless runs on model API errors

DragonnZhang · Sep 11, 2026 · Aug 31, 2026 · Aug 31, 2026 · Aug 31, 2026 · Aug 31, 2026
commit 8b8ebe9047e83cec58f6b9b2f0ce7770f6a7a704
diff --git a/packages/cli/src/nonInteractiveCli.test.ts b/packages/cli/src/nonInteractiveCli.test.ts
@@ -4894,6 +4894,47 @@ describe('runNonInteractive', () => {
     expect(errorOutput).toContain('Incorrect API key provided');
   });
 
+  it('fails stream-json runs when the model stream emits an API error', async () => {
+    (mockConfig.getOutputFormat as Mock).mockReturnValue(
+      OutputFormat.STREAM_JSON,
+    );
+    setupMetricsMock();
+    const apiErrorEvent: ServerLlmStreamEvent = {
+      type: LlmEventType.Error,
+      value: {
+        error: {
+          message: '429 Too Many Requests',
+          status: 429,
+        },
+      },
+    };
+    mockLlmClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents([apiErrorEvent]),
+    );
+
+    await expect(
+      runNonInteractive(
+        mockConfig,
+        mockSettings,
+        'Test input',
+        'prompt-id-stream-api-error',
+      ),
+    ).rejects.toBeInstanceOf(AlreadyReportedError);
+
+    const messages = processStdoutSpy.mock.calls
+      .map((call) => String(call[0]).trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line) as { [key: string]: unknown });
+    const results = messages.filter((message) => message['type'] === 'result');
+
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      subtype: 'error_during_execution',
+      is_error: true,
+      error: { message: expect.stringContaining('429 Too Many Requests') },
+    });
+  });
+
   it('does not double-wrap or double-format an API error in non-interactive mode', async () => {
     // Regression test for the bug where a 4xx error event flowed through
     // both the stream handler and handleError, each calling

diff --git a/packages/cli/src/nonInteractiveCli.ts b/packages/cli/src/nonInteractiveCli.ts
@@ -2418,19 +2418,17 @@ export async function runNonInteractive(
             }
             loopDetected = true;
           }
-          if (
-            outputFormat === OutputFormat.TEXT &&
-            event.type === LlmEventType.Error
-          ) {
+          if (event.type === LlmEventType.Error) {
             const errorText = parseAndFormatApiError(
               event.value.error,
               config.getContentGeneratorConfig()?.authType,
             );
-            process.stderr.write(`${errorText}\n`);
-            // We have already formatted and written the message; mark the
-            // throw so the top-level handleError doesn't reformat (which
-            // would yield "[API Error: [API Error: ...]]") or print it a
-            // second time. Exit code stays 1 — same as before.
+            if (outputFormat === OutputFormat.TEXT) {
+              process.stderr.write(`${errorText}\n`);
+            }
+            // The adapter has already captured the formatted error in JSON
+            // modes, while text mode wrote it above. Mark the throw so the
+            // terminal error result is emitted without formatting it again.
             throw new AlreadyReportedError(errorText);
           }
         }
@@ -2734,18 +2732,15 @@ export async function runNonInteractive(
                   }
                   loopDetected = true;
                 }
-                if (
-                  outputFormat === OutputFormat.TEXT &&
-                  event.type === LlmEventType.Error
-                ) {
+                if (event.type === LlmEventType.Error) {
                   const errorText = parseAndFormatApiError(
                     event.value.error,
                     config.getContentGeneratorConfig()?.authType,
                   );
-                  process.stderr.write(`${errorText}\n`);
-                  // See the matching note in the first stream loop above —
-                  // we mark the throw so handleError doesn't reformat or
-                  // reprint downstream.
+                  if (outputFormat === OutputFormat.TEXT) {
+                    process.stderr.write(`${errorText}\n`);
+                  }
+                  // See the matching main-stream branch above.
                   throw new AlreadyReportedError(errorText);
                 }
               }

diff --git a/packages/cli/src/utils/errors.ts b/packages/cli/src/utils/errors.ts
@@ -22,12 +22,12 @@ import { writeStderrLine } from './stdioHelpers.js';
 const debugLogger = createDebugLogger('CLI_ERRORS');
 
 /**
- * Marker thrown when a producer has already formatted the error message and
- * written it to stderr — the downstream `handleError` should propagate the
- * exit code without printing or reformatting again.
+ * Marker thrown when a producer has already formatted and reported an error
+ * through the active output path — the downstream `handleError` should
+ * propagate the exit code without printing or reformatting it again.
  *
  * The non-interactive runner uses this when an upstream API error event
- * arrives mid-stream: it formats with parseAndFormatApiError, writes once,
+ * arrives mid-stream: it formats with parseAndFormatApiError, reports it,
  * and then throws. Without this marker, handleError would call
  * parseAndFormatApiError a second time on the (now formatted) Error.message,
  * yielding "[API Error: [API Error: ...]]" plus a duplicate stderr line.
@@ -145,7 +145,7 @@ export async function handleError(
   config: Config,
   customErrorCode?: string | number,
 ): Promise<never> {
-  // Producers that already wrote a formatted message to stderr (see
+  // Producers that already reported a formatted message (see
   // AlreadyReportedError above) should not be reprinted or reformatted here.
   // In TEXT mode this short-circuits straight to a clean re-throw; in JSON
   // mode we still emit the structured payload exactly once so machine