Error Handling

2xx - Success

4xx - Client Errors

5xx - Server Errors

authentication_error

Authentication-related errors, such as invalid API keys or expired tokens.

invalid_request_error

Errors related to the format or content of the request.

rate_limit_error

Errors related to exceeding the rate limit for API requests.

medical_data_error

Errors specific to medical data validation or processing.

internal_error

Errors that occur within the Telesoft system.

Implementing Robust Error Handling

Here's an example of a robust error handling implementation using the JavaScript SDK:

import { TelesoftAI, TelesoftAPIError } from '@telesoft/healthcare-sdk';

const telesoft = new TelesoftAI({
  apiKey: 'YOUR_API_KEY',
  environment: 'production'
});

async function handleDiagnosticRequest(patientData) {
  try {
    const result = await telesoft.diagnostics.analyze({
      patientData,
      options: {
        includeConfidenceScores: true
      }
    });
    
    return result;
  } catch (error) {
    if (error instanceof TelesoftAPIError) {
      // Handle API-specific errors
      switch (error.type) {
        case 'authentication_error':
          console.error('Authentication error:', error.message);
          // Refresh credentials or redirect to login
          break;
          
        case 'rate_limit_error':
          const retryAfter = error.headers['retry-after'];
          console.error(`Rate limit exceeded. Retry after ${retryAfter} seconds`);
          // Implement retry logic with exponential backoff
          break;
          
        case 'invalid_request_error':
          console.error('Invalid request:', error.message);
          if (error.param) {
            console.error(`Problem with parameter: ${error.param}`);
          }
          if (error.details) {
            console.error('Error details:', error.details);
          }
          // Fix request parameters
          break;
          
        case 'medical_data_error':
          console.error('Medical data issue:', error.message);
          // Prompt for additional information
          break;
          
        default:
          console.error(`Telesoft API error: ${error.type} - ${error.message}`);
          // Log error for further investigation
      }
      
      // Always include the requestId when contacting support
      console.error(`Request ID: ${error.requestId}`);
      
    } else {
      // Handle network errors or other client-side issues
      console.error('Client-side error:', error);
    }
    
    throw error; // Re-throw or handle according to your application's needs
  }
}

Retrying Failed Requests

Some errors are transient and can be resolved by retrying the request. Here's an example retry implementation:

async function retryableRequest(requestFn, maxRetries = 3, initialDelay = 1000) {
  let attempts = 0;
  let delay = initialDelay;
  
  while (attempts < maxRetries) {
    try {
      return await requestFn();
    } catch (error) {
      attempts++;
      
      // Determine if the error is retryable
      const isRetryable = 
        error instanceof TelesoftAPIError && 
        (error.type === 'rate_limit_error' || 
         error.status === 503 || 
         error.status === 502);
      
      if (!isRetryable || attempts >= maxRetries) {
        throw error; // Not retryable or max retries reached
      }
      
      // Calculate delay with exponential backoff
      // Uses the Retry-After header if available
      if (error.headers && error.headers['retry-after']) {
        delay = parseInt(error.headers['retry-after'], 10) * 1000;
      } else {
        delay = delay * (1.5 + Math.random()); // Exponential backoff with jitter
      }
      
      console.warn(`Request failed. Retrying in ${delay/1000} seconds. Attempt ${attempts} of ${maxRetries}.`);
      
      // Wait before retrying
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}