v2: SdkError tests

packages/client/test/client/sse.test.ts

@@ -1590,6 +1590,7 @@ describe('SSEClientTransport', () => {
             expect(error).toBeInstanceOf(SdkHttpError);
             expect((error as SdkHttpError).code).toBe(SdkErrorCode.ClientHttpAuthentication);
             expect((error as SdkHttpError).status).toBe(401);
+            expect((error as SdkHttpError).statusText).toBe('Unauthorized');
             expect(authProvider.onUnauthorized).toHaveBeenCalledTimes(1);
             expect(postCount).toBe(2);
         });

packages/client/test/client/streamableHttp.test.ts

@@ -1875,6 +1875,7 @@ describe('StreamableHTTPClientTransport', () => {
             expect(error).toBeInstanceOf(SdkHttpError);
             expect((error as SdkHttpError).code).toBe(SdkErrorCode.ClientHttpAuthentication);
             expect((error as SdkHttpError).status).toBe(401);
+            expect((error as SdkHttpError).statusText).toBe('Unauthorized');
             expect(mockAuthProvider.saveTokens).toHaveBeenCalledWith({
                 access_token: 'new-access-token',
                 token_type: 'Bearer',

packages/client/test/client/tokenProvider.test.ts

@@ -95,13 +95,26 @@ describe('StreamableHTTPClientTransport with AuthProvider', () => {
         vi.spyOn(globalThis, 'fetch');
 
         (globalThis.fetch as Mock)
-            .mockResolvedValueOnce({ ok: false, status: 401, headers: new Headers(), text: async () => 'unauthorized' })
-            .mockResolvedValueOnce({ ok: false, status: 401, headers: new Headers(), text: async () => 'unauthorized' });
+            .mockResolvedValueOnce({
+                ok: false,
+                status: 401,
+                statusText: 'Unauthorized',
+                headers: new Headers(),
+                text: async () => 'unauthorized'
+            })
+            .mockResolvedValueOnce({
+                ok: false,
+                status: 401,
+                statusText: 'Unauthorized',
+                headers: new Headers(),
+                text: async () => 'unauthorized'
+            });
 
         const error = await transport.send(message).catch(e => e);
         expect(error).toBeInstanceOf(SdkHttpError);
         expect((error as SdkHttpError).code).toBe(SdkErrorCode.ClientHttpAuthentication);
         expect((error as SdkHttpError).status).toBe(401);
+        expect((error as SdkHttpError).statusText).toBe('Unauthorized');
         expect(authProvider.onUnauthorized).toHaveBeenCalledTimes(1);
     });
 

packages/core/test/errors/sdkHttpError.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { SdkError, SdkErrorCode, SdkHttpError } from '../../src/index.js';
+
+describe('SdkHttpError', () => {
+    it('exposes status and statusText via getters', () => {
+        const error = new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, 'Unauthorized', {
+            status: 401,
+            statusText: 'Unauthorized'
+        });
+
+        expect(error.status).toBe(401);
+        expect(error.statusText).toBe('Unauthorized');
+    });
+
+    it('returns undefined for statusText when omitted', () => {
+        const error = new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, 'auth failed', {
+            status: 401
+        });
+
+        expect(error.status).toBe(401);
+        expect(error.statusText).toBeUndefined();
+    });
+
+    it('is an instance of SdkError', () => {
+        const error = new SdkHttpError(SdkErrorCode.ClientHttpForbidden, 'Forbidden', {
+            status: 403,
+            statusText: 'Forbidden'
+        });
+
+        expect(error).toBeInstanceOf(SdkError);
+        expect(error).toBeInstanceOf(SdkHttpError);
+    });
+
+    it('preserves code and message from SdkError', () => {
+        const error = new SdkHttpError(SdkErrorCode.ClientHttpNotImplemented, 'Not Implemented', {
+            status: 501,
+            statusText: 'Not Implemented'
+        });
+
+        expect(error.code).toBe(SdkErrorCode.ClientHttpNotImplemented);
+        expect(error.message).toBe('Not Implemented');
+        expect(error.name).toBe('SdkHttpError');
+    });
+
+    it('exposes extra data fields alongside status', () => {
+        const error = new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, 'auth failed', {
+            status: 401,
+            statusText: 'Unauthorized',
+            retryAfter: 30
+        });
+
+        expect(error.data.retryAfter).toBe(30);
+        expect(error.status).toBe(401);
+    });
+});