@@ -0,0 +1,5 @@
+---
+'@ai-sdk/gateway': patch
+---
+
+fix(gateway): Preserve AbortError and TimeoutError cancellation reasons instead of wrapping them in retryable GatewayResponseError errors with status 500. Propagate these errors from speech and transcription input streams to their output streams without leaving reads pending or causing unhandled rejections.
@@ -8,6 +8,26 @@ import {
 } from './index';
 
 describe('asGatewayError', () => {
+  describe('caller cancellation', () => {
+    it.each(['AbortError', 'TimeoutError'])(
+      'should rethrow a %s DOMException unchanged',
+      async name => {
+        const error = new DOMException('Request cancelled', name);
+
+        await expect(asGatewayError(error)).rejects.toBe(error);
+      },
+    );
+
+    it.each(['AbortError', 'TimeoutError'])(
+      'should rethrow an Error named %s unchanged',
+      async name => {
+        const error = Object.assign(new Error('Request cancelled'), { name });
+
+        await expect(asGatewayError(error)).rejects.toBe(error);
+      },
+    );
+  });
+
   describe('timeout error detection', () => {
     it('should detect error with UND_ERR_HEADERS_TIMEOUT code', async () => {
       const error = Object.assign(new Error('Request timeout'), {
 
@@ -31,6 +31,15 @@ export async function asGatewayError(
   error: unknown,
   authMethod?: 'api-key' | 'oidc',
 ) {
+  // Caller cancellation is not a gateway failure and must not become a retryable 500.
+  if (
+    (error instanceof Error ||
+      (typeof DOMException === 'function' && error instanceof DOMException)) &&
+    (error.name === 'AbortError' || error.name === 'TimeoutError')
+  ) {
+    throw error;
+  }
+
   if (GatewayError.isInstance(error)) {
     return error;
   }
 
@@ -54,6 +54,30 @@ describe('GatewayLanguageModel', () => {
     });
   });
 
+  describe.each(['doGenerate', 'doStream'] as const)(
+    '%s cancellation',
+    method => {
+      it.each(['AbortError', 'TimeoutError'])(
+        'should preserve the original %s from fetch',
+        async name => {
+          const error = new DOMException('Request cancelled', name);
+          const controller = new AbortController();
+          controller.abort(error);
+          const model = createTestModel({
+            fetch: vi.fn().mockRejectedValue(error),
+          });
+
+          await expect(
+            model[method]({
+              prompt: TEST_PROMPT,
+              abortSignal: controller.signal,
+            }),
+          ).rejects.toBe(error);
+        },
+      );
+    },
+  );
+
   describe('doGenerate', () => {
     function prepareJsonResponse({
       content = { type: 'text', text: '' },
 
@@ -295,6 +295,33 @@ describe('GatewaySpeechModel.doStream', () => {
     );
   });
 
+  it.each(['AbortError', 'TimeoutError'])(
+    'should propagate an upstream text %s unchanged',
+    async name => {
+      const error = new DOMException('Text stream cancelled', name);
+      let textController!: ReadableStreamDefaultController<SpeechModelV4StreamTextPart>;
+      const result = await createStreamingTestModel().doStream({
+        text: new ReadableStream<SpeechModelV4StreamTextPart>({
+          start(controller) {
+            textController = controller;
+          },
+        }),
+      });
+      const socket = lastSocket();
+      socket.open();
+      await flush();
+
+      const reader = result.stream.getReader();
+      const rejection = expect(reader.read()).rejects.toBe(error);
+      textController.error(error);
+
+      await rejection;
+      await expect(reader.read()).rejects.toBe(error);
+      await flush();
+      expect(socket.close).toHaveBeenCalled();
+    },
+  );
+
   it('should send an empty text part that carries a voice or provider options', async () => {
     await createStreamingTestModel().doStream({
       text: convertArrayToReadableStream<SpeechModelV4StreamTextPart>([
 
@@ -10,7 +10,10 @@ export async function errorControllerWithGatewayError<PART>(
   error: unknown,
   authMethod: 'api-key' | 'oidc' | undefined,
 ): Promise<void> {
-  controller.error(await asGatewayError(error, authMethod));
+  // Cancellation errors are rethrown by asGatewayError and must still reach the stream.
+  controller.error(
+    await asGatewayError(error, authMethod).catch(error => error),
+  );
 }
 
 /**
 
@@ -917,6 +917,34 @@ describe('GatewayTranscriptionModel', () => {
       expect(ws.close).toHaveBeenCalled();
     });
 
+    it.each(['AbortError', 'TimeoutError'])(
+      'should propagate an upstream audio %s unchanged',
+      async name => {
+        const error = new DOMException('Audio stream cancelled', name);
+        let audioController!: ReadableStreamDefaultController<Uint8Array>;
+        const result = await createStreamingTestModel().doStream({
+          audio: new ReadableStream<Uint8Array>({
+            start(controller) {
+              audioController = controller;
+            },
+          }),
+          inputAudioFormat: { type: 'audio/pcm', rate: 16000 },
+        });
+        const ws = MockWebSocket.instances[0];
+        ws.open();
+        await flush();
+
+        const reader = result.stream.getReader();
+        const rejection = expect(reader.read()).rejects.toBe(error);
+        audioController.error(error);
+
+        await rejection;
+        await expect(reader.read()).rejects.toBe(error);
+        await flush();
+        expect(ws.close).toHaveBeenCalled();
+      },
+    );
+
     it('should cancel the audio stream when the connection fails before open', async () => {
       const model = createStreamingTestModel();
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@ai-sdk/gateway': patch
 +---
++
 +fix(gateway): Preserve AbortError and TimeoutError cancellation reasons instead of wrapping them in retryable GatewayResponseError errors with status 500. Propagate these errors from speech and transcription input streams to their output streams without leaving reads pending or causing unhandled rejections.