Use ai sdk error codes instead of our own error code schema

Author: jahooma

cli/src/__tests__/integration/api-integration.test.ts

@@ -1,6 +1,4 @@
 import {
-  AuthenticationError,
-  NetworkError,
   getUserInfoFromApiKey,
 } from '@codebuff/sdk'
 import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test'
@@ -143,7 +141,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(AuthenticationError)
+      ).rejects.toMatchObject({ statusCode: 401 })
 
       // 401s are now logged as auth failures
       expect(testLogger.error.mock.calls.length).toBeGreaterThan(0)
@@ -161,7 +159,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(AuthenticationError)
+      ).rejects.toMatchObject({ statusCode: 401 })
 
       expect(testLogger.error.mock.calls.length).toBeGreaterThan(0)
     })
@@ -180,7 +178,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(NetworkError)
+      ).rejects.toMatchObject({ statusCode: expect.any(Number) })
 
       expect(testLogger.error.mock.calls.length).toBeGreaterThan(0)
     })
@@ -197,7 +195,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(NetworkError)
+      ).rejects.toMatchObject({ statusCode: expect.any(Number) })
 
       expect(
         testLogger.error.mock.calls.some(([payload]) =>
@@ -218,7 +216,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(NetworkError)
+      ).rejects.toMatchObject({ statusCode: expect.any(Number) })
 
       expect(testLogger.error.mock.calls.length).toBeGreaterThan(0)
     })
@@ -239,7 +237,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(NetworkError)
+      ).rejects.toMatchObject({ statusCode: expect.any(Number) })
 
       expect(fetchMock.mock.calls.length).toBe(1)
       expect(
@@ -263,7 +261,7 @@ describe('API Integration', () => {
           fields: ['id'],
           logger: testLogger,
         }),
-      ).rejects.toBeInstanceOf(NetworkError)
+      ).rejects.toMatchObject({ statusCode: expect.any(Number) })
 
       expect(fetchMock.mock.calls.length).toBe(1)
       expect(

cli/src/app.tsx

@@ -1,4 +1,4 @@
-import { NetworkError, RETRYABLE_ERROR_CODES } from '@codebuff/sdk'
+import { isRetryableStatusCode, getErrorStatusCode } from '@codebuff/sdk'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 
@@ -213,15 +213,13 @@ export const App = ({
 
   // Derive auth reachability + retrying state inline from authQuery error
   const authError = authQuery.error
-  const networkError =
-    authError && authError instanceof NetworkError ? authError : null
-  const isRetryableNetworkError = Boolean(
-    networkError && RETRYABLE_ERROR_CODES.has(networkError.code),
-  )
+  const authErrorStatusCode = authError ? getErrorStatusCode(authError) : undefined
+  const isRetryableNetworkError = authErrorStatusCode !== undefined && isRetryableStatusCode(authErrorStatusCode)
 
   let authStatus: AuthStatus = 'ok'
   if (authQuery.isError) {
-    if (!networkError) {
+    // Only show network status if it's a server/network error (5xx)
+    if (authErrorStatusCode === undefined || authErrorStatusCode < 500) {
       authStatus = 'ok'
     } else if (isRetryableNetworkError) {
       authStatus = 'retrying'

cli/src/hooks/helpers/__tests__/send-message.test.ts

@@ -34,7 +34,7 @@ const { setupStreamingContext, handleRunError } = await import(
 const { createBatchedMessageUpdater } = await import(
   '../../../utils/message-updater'
 )
-const { PaymentRequiredError } = await import('@codebuff/sdk')
+import { createPaymentRequiredError } from '@codebuff/sdk'
 
 const createMockTimerController = (): SendMessageTimerController & {
   startCalls: string[]
@@ -375,7 +375,7 @@ describe('handleRunError', () => {
     expect(mockInvalidateQueries).not.toHaveBeenCalled()
   })
 
-  test('PaymentRequiredError uses setError, invalidates queries, and switches input mode', () => {
+  test('Payment required error (402) uses setError, invalidates queries, and switches input mode', () => {
     let messages: ChatMessage[] = [
       {
         id: 'ai-1',
@@ -397,7 +397,7 @@ describe('handleRunError', () => {
       setInputMode: setInputModeMock,
     })
 
-    const paymentError = new PaymentRequiredError('Out of credits')
+    const paymentError = createPaymentRequiredError('Out of credits')
 
     handleRunError({
       error: paymentError,

cli/src/hooks/use-auth-query.ts

@@ -2,11 +2,11 @@ import { createHash } from 'crypto'
 
 import { getCiEnv } from '@codebuff/common/env-ci'
 import {
-  AuthenticationError,
-  ErrorCodes,
   getUserInfoFromApiKey as defaultGetUserInfoFromApiKey,
-  NetworkError,
-  RETRYABLE_ERROR_CODES,
+  isRetryableStatusCode,
+  getErrorStatusCode,
+  createAuthError,
+  createServerError,
   MAX_RETRIES_PER_MESSAGE,
   RETRY_BACKOFF_BASE_DELAY_MS,
 } from '@codebuff/sdk'
@@ -47,6 +47,14 @@ type ValidatedUserInfo = {
   email: string
 }
 
+/**
+ * Check if an error is an authentication error (401, 403)
+ */
+function isAuthenticationError(error: unknown): boolean {
+  const statusCode = getErrorStatusCode(error)
+  return statusCode === 401 || statusCode === 403
+}
+
 /**
  * Validates an API key by calling the backend
  *
@@ -69,42 +77,39 @@ export async function validateApiKey({
 
     if (!authResult) {
       logger.error('❌ API key validation failed - invalid credentials')
-      throw new AuthenticationError('Invalid API key', 401)
+      throw createAuthError('Invalid API key')
     }
 
     return authResult
   } catch (error) {
-    if (error instanceof AuthenticationError) {
+    const statusCode = getErrorStatusCode(error)
+
+    if (isAuthenticationError(error)) {
       logger.error('❌ API key validation failed - authentication error')
-      // Rethrow the original error to preserve error type for higher layers
+      // Rethrow the original error to preserve statusCode for higher layers
       throw error
     }
 
-    if (error instanceof NetworkError) {
+    if (statusCode !== undefined && isRetryableStatusCode(statusCode)) {
       logger.error(
         {
-          error: error.message,
-          code: error.code,
+          error: error instanceof Error ? error.message : String(error),
+          statusCode,
         },
         '❌ API key validation failed - network error',
       )
-      // Rethrow the original error to preserve error type for higher layers
+      // Rethrow the original error to preserve statusCode for higher layers
       throw error
     }
 
-    // Unknown error - wrap in NetworkError for consistency
+    // Unknown error - wrap with statusCode for consistency
     logger.error(
       {
         error: error instanceof Error ? error.message : String(error),
       },
       '❌ API key validation failed - unknown error',
     )
-    throw new NetworkError(
-      'Authentication failed',
-      ErrorCodes.UNKNOWN_ERROR,
-      undefined,
-      error,
-    )
+    throw createServerError('Authentication failed')
   }
 }
 
@@ -139,12 +144,13 @@ export function useAuthQuery(deps: UseAuthQueryDeps = {}) {
     // Retry only for retryable network errors (5xx, timeouts, etc.)
     // Don't retry authentication errors (invalid credentials)
     retry: (failureCount, error) => {
+      const statusCode = getErrorStatusCode(error)
       // Don't retry authentication errors - user needs to update credentials
-      if (error instanceof AuthenticationError) {
+      if (isAuthenticationError(error)) {
         return false
       }
       // Retry network errors if they're retryable and we haven't exceeded max retries
-      if (error instanceof NetworkError && RETRYABLE_ERROR_CODES.has(error.code)) {
+      if (statusCode !== undefined && isRetryableStatusCode(statusCode)) {
         return failureCount < MAX_RETRIES_PER_MESSAGE
       }
       // Don't retry other errors

cli/src/utils/create-run-config.ts

@@ -30,12 +30,12 @@ export type CreateRunConfigParams = {
 type RetryArgs = {
   attempt: number
   delayMs: number
-  errorCode?: string
+  statusCode?: number
 }
 
 type RetryExhaustedArgs = {
   totalAttempts: number
-  errorCode?: string
+  statusCode?: number
 }
 
 export const createRunConfig = (params: CreateRunConfigParams) => {
@@ -63,19 +63,19 @@ export const createRunConfig = (params: CreateRunConfigParams) => {
       maxRetries: MAX_RETRIES_PER_MESSAGE,
       backoffBaseMs: RETRY_BACKOFF_BASE_DELAY_MS,
       backoffMaxMs: RETRY_BACKOFF_MAX_DELAY_MS,
-      onRetry: async ({ attempt, delayMs, errorCode }: RetryArgs) => {
+      onRetry: async ({ attempt, delayMs, statusCode }: RetryArgs) => {
         logger.warn(
-          { sdkAttempt: attempt, delayMs, errorCode },
+          { sdkAttempt: attempt, delayMs, statusCode },
           'SDK retrying after error',
         )
         setIsRetrying(true)
         setStreamStatus('waiting')
       },
       onRetryExhausted: async ({
         totalAttempts,
-        errorCode,
+        statusCode,
       }: RetryExhaustedArgs) => {
-        logger.warn({ totalAttempts, errorCode }, 'SDK exhausted all retries')
+        logger.warn({ totalAttempts, statusCode }, 'SDK exhausted all retries')
       },
     },
     agentDefinitions,

cli/src/utils/error-handling.ts

@@ -1,5 +1,4 @@
 import { env } from '@codebuff/common/env'
-import { ErrorCodes, isPaymentRequiredError } from '@codebuff/sdk'
 
 import type { ChatMessage } from '../types/chat'
 
@@ -14,7 +13,7 @@ const extractErrorMessage = (error: unknown, fallback: string): string => {
     return error.message + (error.stack ? `\n\n${error.stack}` : '')
   }
   if (error && typeof error === 'object' && 'message' in error) {
-    const candidate = (error as any).message
+    const candidate = (error as { message: unknown }).message
     if (typeof candidate === 'string' && candidate.length > 0) {
       return candidate
     }
@@ -27,16 +26,14 @@ const extractErrorMessage = (error: unknown, fallback: string): string => {
  * Standardized on statusCode === 402 for payment required detection.
  */
 export const isOutOfCreditsError = (error: unknown): boolean => {
-  // Check for error output with errorCode property (from agent run results)
   if (
     error &&
     typeof error === 'object' &&
     'statusCode' in error &&
-    error.statusCode === 402
+    (error as { statusCode: unknown }).statusCode === 402
   ) {
     return true
   }
-
   return false
 }
 
@@ -55,6 +52,3 @@ export const createErrorMessage = (
     isComplete: true,
   }
 }
-
-// Re-export for convenience in helpers
-export { isPaymentRequiredError }

cli/src/utils/error-messages.ts

@@ -1,62 +1,35 @@
-import {
-  AuthenticationError,
-  NetworkError,
-  ErrorCodes,
-  isErrorWithCode,
-  sanitizeErrorMessage,
-} from '@codebuff/sdk'
+import { sanitizeErrorMessage, getErrorStatusCode } from '@codebuff/sdk'
 
 /**
  * Formats an unknown error into a user-facing markdown string.
  *
- * The goal is to provide clear, consistent messaging across the CLI while
- * reusing the SDK error typing and sanitization logic.
+ * The goal is to provide clear, consistent messaging across the CLI.
  */
 export function formatErrorForDisplay(error: unknown, fallbackTitle: string): string {
-  // Authentication-specific messaging
-  if (error instanceof AuthenticationError) {
-    if (error.status === 401) {
-      return `${fallbackTitle}: Authentication failed. Please check your API key.`
-    }
-
-    if (error.status === 403) {
-      return `${fallbackTitle}: Access forbidden. You do not have permission to access this resource.`
-    }
+  const statusCode = getErrorStatusCode(error)
 
-    return `${fallbackTitle}: Invalid API key. Please check your credentials.`
+  // Authentication-specific messaging based on statusCode
+  if (statusCode === 401) {
+    return `${fallbackTitle}: Authentication failed. Please check your API key.`
   }
-
-  // Network-specific messaging
-  if (error instanceof NetworkError) {
-    let detail: string
-
-    switch (error.code) {
-      case ErrorCodes.TIMEOUT:
-        detail = 'Request timed out. Please check your internet connection.'
-        break
-      case ErrorCodes.CONNECTION_REFUSED:
-        detail = 'Connection refused. The server may be down.'
-        break
-      case ErrorCodes.DNS_FAILURE:
-        detail = 'DNS resolution failed. Please check your internet connection.'
-        break
-      case ErrorCodes.SERVER_ERROR:
-      case ErrorCodes.SERVICE_UNAVAILABLE:
-        detail = 'Server error. Please try again later.'
-        break
-      case ErrorCodes.NETWORK_ERROR:
-      default:
-        detail = 'Network error. Please check your internet connection.'
-        break
-    }
-
-    return `${fallbackTitle}: ${detail}`
+  if (statusCode === 403) {
+    return `${fallbackTitle}: Access forbidden. You do not have permission to access this resource.`
   }
 
-  // Any other typed error that exposes a code
-  if (isErrorWithCode(error)) {
-    const safeMessage = sanitizeErrorMessage(error)
-    return `${fallbackTitle}: ${safeMessage}`
+  // Network/server error messaging based on statusCode
+  if (statusCode !== undefined) {
+    if (statusCode === 408) {
+      return `${fallbackTitle}: Request timed out. Please check your internet connection.`
+    }
+    if (statusCode === 503) {
+      return `${fallbackTitle}: Service unavailable. The server may be down.`
+    }
+    if (statusCode >= 500) {
+      return `${fallbackTitle}: Server error. Please try again later.`
+    }
+    if (statusCode === 429) {
+      return `${fallbackTitle}: Rate limited. Please try again later.`
+    }
   }
 
   // Generic Error instance
@@ -65,8 +38,9 @@ export function formatErrorForDisplay(error: unknown, fallbackTitle: string): st
     return `${fallbackTitle}: ${message}`
   }
 
-  // Fallback for unknown values
-  return `${fallbackTitle}: ${String(error)}`
+  // Try sanitizeErrorMessage for other cases
+  const safeMessage = sanitizeErrorMessage(error)
+  return `${fallbackTitle}: ${safeMessage}`
 }
 
 /**