fix(core): recognize OpenAI SDK APIUserAbortError as an abort

packages/core/src/core/loggingContentGenerator/loggingContentGenerator.test.ts

@@ -25,6 +25,7 @@ import {
 import { isTelemetrySdkInitialized } from '../../telemetry/index.js';
 import { OpenAILogger } from '../../utils/openaiLogger.js';
 import type OpenAI from 'openai';
+import { APIUserAbortError } from 'openai';
 import { setGenAiUsageProvenance } from '../../telemetry/gen-ai-usage.js';
 
 const activeOtelContext = vi.hoisted(() => ({ current: 'root' }));
@@ -764,6 +765,64 @@ describe('LoggingContentGenerator', () => {
     ).toHaveBeenCalledWith(false);
   });
 
+  it('does not emit an api_error event when the user cancelled the request', async () => {
+    // A user cancel surfaces as the SDK's APIUserAbortError with the caller's
+    // signal aborted. It must not be reported as a qwen-code.api_error — the
+    // span already records the cancellation. Regression for #8356 at the layer
+    // the bug is about: the util-level isAbortError fix alone does not gate this
+    // separate telemetry path.
+    const wrapped = createWrappedGenerator(
+      vi
+        .fn()
+        .mockRejectedValue(
+          new APIUserAbortError({ message: 'Request was aborted.' }),
+        ),
+      vi.fn(),
+    );
+    const generator = new LoggingContentGenerator(wrapped, createConfig(), {
+      model: 'test-model',
+      authType: AuthType.USE_OPENAI,
+      enableOpenAILogging: false,
+    });
+    const controller = new AbortController();
+    controller.abort();
+    const request = {
+      model: 'test-model',
+      contents: 'Hello',
+      config: { abortSignal: controller.signal },
+    } as unknown as GenerateContentParameters;
+
+    await expect(
+      generator.generateContent(request, 'prompt-cancel'),
+    ).rejects.toBeInstanceOf(APIUserAbortError);
+
+    expect(logApiError).not.toHaveBeenCalled();
+  });
+
+  it('still emits an api_error event for a real failure that is not a cancel', async () => {
+    // The gate is scoped to genuine user cancels: a non-abort failure, even
+    // with an unrelated aborted flag absent, must still be reported.
+    const wrapped = createWrappedGenerator(
+      vi.fn().mockRejectedValue(new Error('upstream-down')),
+      vi.fn(),
+    );
+    const generator = new LoggingContentGenerator(wrapped, createConfig(), {
+      model: 'test-model',
+      authType: AuthType.USE_OPENAI,
+      enableOpenAILogging: false,
+    });
+    const request = {
+      model: 'test-model',
+      contents: 'Hello',
+    } as unknown as GenerateContentParameters;
+
+    await expect(
+      generator.generateContent(request, 'prompt-real-error'),
+    ).rejects.toThrow('upstream-down');
+
+    expect(logApiError).toHaveBeenCalledTimes(1);
+  });
+
   it('forwards usage attached to the final response after it was yielded', async () => {
     const response = createResponse('r1', 'test-model', [{ text: 'a' }]);
     const streamFn = vi.fn().mockResolvedValue(

packages/core/src/core/loggingContentGenerator/loggingContentGenerator.ts

@@ -49,6 +49,7 @@ import {
   getErrorMessage,
   getErrorStatus,
   getErrorType,
+  isAbortError,
 } from '../../utils/errors.js';
 import {
   startLLMRequestSpan,
@@ -262,7 +263,18 @@ export class LoggingContentGenerator implements ContentGenerator {
     error: unknown,
     model: string,
     prompt_id: string,
+    abortSignal?: AbortSignal,
   ): void {
+    // A user cancel is not an API error. When the caller's signal is aborted
+    // and the error is abort-shaped, skip the api_error event entirely — the
+    // span already records the cancellation through its aborted status, so the
+    // signal isn't lost. Without this gate a user cancel is still emitted as a
+    // `qwen-code.api_error` event with error_type `APIUserAbortError`, which is
+    // exactly what #8356 reported; `isAbortError` gating the debug log alone
+    // does not cover this separate telemetry path.
+    if (abortSignal?.aborted && isAbortError(error)) {
+      return;
+    }
     try {
       this._logApiError(responseId, durationMs, error, model, prompt_id);
     } catch (loggingError) {
@@ -402,7 +414,14 @@ export class LoggingContentGenerator implements ContentGenerator {
         config: this.config,
       });
       await context.with(spanContext, async () => {
-        this.safelyLogApiError('', durationMs, error, req.model, userPromptId);
+        this.safelyLogApiError(
+          '',
+          durationMs,
+          error,
+          req.model,
+          userPromptId,
+          req.config?.abortSignal,
+        );
         try {
           await this.safelyLogOpenAIInteraction(
             await session.resolve(req),
@@ -490,7 +509,14 @@ export class LoggingContentGenerator implements ContentGenerator {
       const durationMs = Date.now() - startTime;
       const observedFinishReasons = exchange.controller.finalize(false);
       context.with(spanContext, () =>
-        this.safelyLogApiError('', durationMs, error, req.model, userPromptId),
+        this.safelyLogApiError(
+          '',
+          durationMs,
+          error,
+          req.model,
+          userPromptId,
+          req.config?.abortSignal,
+        ),
       );
       const aborted = req.config?.abortSignal?.aborted ?? false;
       endLLMRequestSpan(llmSpan, {
@@ -802,6 +828,7 @@ export class LoggingContentGenerator implements ContentGenerator {
             error,
             firstModelVersion || model,
             userPromptId,
+            abortSignal,
           ),
         );
         const openaiRequest = await openaiRequestPromise;

packages/core/src/utils/errors.test.ts

@@ -5,6 +5,8 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { APIUserAbortError as AnthropicAPIUserAbortError } from '@anthropic-ai/sdk';
+import { APIConnectionError, APIUserAbortError } from 'openai';
 import { getErrorMessage, isAbortError, isNodeError } from './errors.js';
 
 describe('getErrorMessage cause unwrapping', () => {
@@ -231,6 +233,44 @@ describe('isAbortError', () => {
 
     expect(isAbortError(networkError)).toBe(false);
   });
+
+  it('should return true for the OpenAI SDK APIUserAbortError (user cancel)', () => {
+    // The OpenAI SDK is the request path for auth_type=openai; a user cancel
+    // surfaces as APIUserAbortError. It does not set `.name` (stays 'Error')
+    // and has no ABORT_ERR code, so the checks above miss it.
+    const error = new APIUserAbortError({ message: 'Request was aborted.' });
+
+    // Assert the requirement (the name-based branch can't match it) rather than
+    // the SDK internal `.name === 'Error'`, which would break if OpenAI/Anthropic
+    // ever set a name without changing the correct behavior here.
+    expect(error.name).not.toBe('AbortError');
+    expect(isAbortError(error)).toBe(true);
+  });
+
+  it('should return true for the Anthropic SDK APIUserAbortError', () => {
+    // Both SDKs this package depends on are Stainless-generated and share the
+    // abort class name, so the same check covers auth_type=anthropic. Pinned so
+    // the cross-SDK coverage is intentional rather than incidental.
+    const error = new AnthropicAPIUserAbortError({
+      message: 'Request was aborted.',
+    });
+
+    // Assert the requirement (the name-based branch can't match it) rather than
+    // the SDK internal `.name === 'Error'`, which would break if OpenAI/Anthropic
+    // ever set a name without changing the correct behavior here.
+    expect(error.name).not.toBe('AbortError');
+    expect(isAbortError(error)).toBe(true);
+  });
+
+  it('should return false for other SDK errors such as APIConnectionError', () => {
+    // Guards the abort match against being broadened (e.g. to any `API*`
+    // class): a transient connection failure must stay retryable, not be
+    // reported as a user cancellation.
+    const error = new APIConnectionError({ message: 'Connection error.' });
+
+    expect(error.constructor.name).toBe('APIConnectionError');
+    expect(isAbortError(error)).toBe(false);
+  });
 });
 
 describe('isNodeError', () => {

packages/core/src/utils/errors.ts

@@ -18,7 +18,8 @@ export function isNodeError(error: unknown): error is NodeJS.ErrnoException {
 
 /**
  * Check if the error is an abort error (user cancellation).
- * This handles both DOMException-style AbortError and Node.js abort errors.
+ * This handles DOMException-style AbortError, Node.js abort errors, and the
+ * provider SDKs' `APIUserAbortError` (matched by class name).
  */
 export function isAbortError(error: unknown): boolean {
   if (!error || typeof error !== 'object') {
@@ -35,6 +36,24 @@ export function isAbortError(error: unknown): boolean {
     return true;
   }
 
+  // A user cancel on a provider SDK path surfaces as `APIUserAbortError`. That
+  // class does not set `.name` (it stays 'Error') and carries no ABORT_ERR
+  // code, so the checks above miss it — leaving user cancels logged as
+  // api_errors and classified 'unknown' rather than 'abort'. Both SDKs this
+  // package depends on (`openai`, `@anthropic-ai/sdk`) are Stainless-generated
+  // and share this class name, so one check covers both. Match on the class
+  // name — as `getErrorType` below already does for SDK errors — so this
+  // provider-agnostic util needs no SDK import. The CLI bundle preserves class
+  // names (esbuild `keepNames: true` in esbuild.config.js); other bundles that
+  // minify without keepNames (e.g. vscode-ide-companion) do not, but they don't
+  // drive provider SDK requests, so the match holds where it runs.
+  if (
+    error instanceof Error &&
+    error.constructor?.name === 'APIUserAbortError'
+  ) {
+    return true;
+  }
+
   return false;
 }
 

packages/core/src/utils/retryErrorClassification.test.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { APIUserAbortError } from 'openai';
 import { describe, expect, it } from 'vitest';
 import { AuthType } from '../core/contentGenerator.js';
 import {
@@ -23,6 +24,17 @@ describe('classifyRetryError', () => {
     });
   });
 
+  it('classifies the OpenAI SDK APIUserAbortError as an abort, not unknown', () => {
+    // A user cancel on the auth_type=openai path surfaces as APIUserAbortError.
+    // It must be treated as an abort so retries stop and it is not logged as an
+    // api_error — otherwise it falls through to the 'unknown' classification.
+    expect(
+      classifyRetryError(
+        new APIUserAbortError({ message: 'Request was aborted.' }),
+      ),
+    ).toMatchObject({ kind: 'abort' });
+  });
+
   it('classifies HTTP 503 as retryable rate limiting to match stream retry semantics', () => {
     expect(
       classifyRetryError({ status: 503, message: 'Provider overloaded' }),