fix(test): replace broken MSW mocks with direct fetch mocking in download tests

MSW was not intercepting fetch() calls, causing 2 tests to fail against
the real http://example.com. Switched to globalThis.fetch mocking to
match the pattern used in download-blob.test.ts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gr2m

packages/ai/src/util/download/download.test.ts

@@ -1,12 +1,6 @@
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
 import { DownloadError } from '@ai-sdk/provider-utils';
 import { download } from './download';
-import { describe, it, expect, vi, afterEach } from 'vitest';
-
-const server = createTestServer({
-  'http://example.com/file': {},
-  'http://example.com/large': {},
-});
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
 
 describe('download SSRF protection', () => {
   it('should reject private IPv4 addresses', async () => {
@@ -100,16 +94,32 @@ describe('download SSRF redirect protection', () => {
 });
 
 describe('download', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
   it('should download data successfully and match expected bytes', async () => {
     const expectedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
 
-    server.urls['http://example.com/file'].response = {
-      type: 'binary',
-      headers: {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers({
         'content-type': 'application/octet-stream',
-      },
-      body: Buffer.from(expectedBytes),
-    };
+      }),
+      body: new ReadableStream({
+        start(controller) {
+          controller.enqueue(expectedBytes);
+          controller.close();
+        },
+      }),
+    } as unknown as Response);
 
     const result = await download({
       url: new URL('http://example.com/file'),
@@ -119,16 +129,21 @@ describe('download', () => {
     expect(result!.data).toEqual(expectedBytes);
     expect(result!.mediaType).toBe('application/octet-stream');
 
-    // UA header assertion
-    expect(server.calls[0].requestUserAgent).toContain('ai-sdk/');
+    expect(fetch).toHaveBeenCalledWith(
+      'http://example.com/file',
+      expect.objectContaining({
+        headers: expect.any(Object),
+      }),
+    );
   });
 
   it('should throw DownloadError when response is not ok', async () => {
-    server.urls['http://example.com/file'].response = {
-      type: 'error',
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
       status: 404,
-      body: 'Not Found',
-    };
+      statusText: 'Not Found',
+      headers: new Headers(),
+    } as unknown as Response);
 
     try {
       await download({
@@ -143,11 +158,7 @@ describe('download', () => {
   });
 
   it('should throw DownloadError when fetch throws an error', async () => {
-    server.urls['http://example.com/file'].response = {
-      type: 'error',
-      status: 500,
-      body: 'Network error',
-    };
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
 
     try {
       await download({
@@ -160,15 +171,20 @@ describe('download', () => {
   });
 
   it('should abort when response exceeds default size limit', async () => {
-    // Create a response that claims to be larger than 2 GiB
-    server.urls['http://example.com/large'].response = {
-      type: 'binary',
-      headers: {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers({
         'content-type': 'application/octet-stream',
         'content-length': `${3 * 1024 * 1024 * 1024}`,
-      },
-      body: Buffer.from(new Uint8Array(10)),
-    };
+      }),
+      body: new ReadableStream({
+        start(controller) {
+          controller.enqueue(new Uint8Array(10));
+          controller.close();
+        },
+      }),
+    } as unknown as Response);
 
     try {
       await download({
@@ -187,13 +203,11 @@ describe('download', () => {
     const controller = new AbortController();
     controller.abort();
 
-    server.urls['http://example.com/file'].response = {
-      type: 'binary',
-      headers: {
-        'content-type': 'application/octet-stream',
-      },
-      body: Buffer.from(new Uint8Array([1, 2, 3])),
-    };
+    globalThis.fetch = vi
+      .fn()
+      .mockRejectedValue(
+        new DOMException('The operation was aborted.', 'AbortError'),
+      );
 
     try {
       await download({
@@ -202,8 +216,14 @@ describe('download', () => {
       });
       expect.fail('Expected download to throw');
     } catch (error: unknown) {
-      // The fetch should be aborted, resulting in a DownloadError wrapping an AbortError
       expect(DownloadError.isInstance(error)).toBe(true);
     }
+
+    expect(fetch).toHaveBeenCalledWith(
+      'http://example.com/file',
+      expect.objectContaining({
+        signal: controller.signal,
+      }),
+    );
   });
 });