AI Development Process

type AIResponse = {
  content: string;
  confidence: number;
  metadata: {
    model: string;
    tokens: number;
    processingTime: number;
  };
};

type ErrorResponse = {
  code: string;
  message: string;
  details?: Record<string, unknown>;
};

const validateAIResponse = (response: AIResponse): boolean => {
  if (!response.content || typeof response.content !== 'string') {
    throw new Error('Invalid response content');
  }
  
  if (response.confidence < 0 || response.confidence > 1) {
    throw new Error('Confidence score out of range');
  }
  
  // Additional validation logic
  return true;
};

try {
  const response = await aiService.generateResponse(prompt);
  const isValid = validateAIResponse(response);
  
  if (!isValid) {
    throw new Error('Response validation failed');
  }
  
  return response;
} catch (error) {
  logger.error('AI Response Error:', error);
  return fallbackResponse(error);
}

You are a sentiment analysis expert. Analyze the following customer feedback:
Context: E-commerce product review
Required Output Format: {
  sentiment: "positive" | "negative" | "neutral",
  confidence: number (0-1),
  key_points: string[],
  suggested_actions?: string[]
}
Text to analyze: {{text}}

// ai.service.ts
import { OpenAI } from 'openai';
import { SentimentResponse, ErrorResponse } from './types';
import { validateResponse } from './validators';
import { logger } from './logger';

export class SentimentAnalysisService {
  private openai: OpenAI;
  
  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
  }

  async analyzeSentiment(text: string): Promise<SentimentResponse> {
    try {
      const response = await this.openai.chat.completions.create({
        model: "gpt-4",
        messages: [{
          role: "system",
          content: this.buildPrompt(text)
        }],
        temperature: 0.3,
        response_format: { type: "json_object" }
      });

      const result = JSON.parse(response.choices[0].message.content);
      validateResponse(result);
      
      return result;
    } catch (error) {
      logger.error('Sentiment Analysis Error:', error);
      throw this.handleError(error);
    }
  }

  private buildPrompt(text: string): string {
    return promptTemplate.replace('{{text}}', text);
  }
}

// error-handler.ts
export class AIServiceError extends Error {
  constructor(
    message: string,
    public code: string,
    public details?: Record<string, unknown>
  ) {
    super(message);
    this.name = 'AIServiceError';
  }
}

export const handleError = (error: unknown): AIServiceError => {
  if (error instanceof OpenAI.APIError) {
    return new AIServiceError(
      'AI Service API Error',
      'AI_SERVICE_ERROR',
      { statusCode: error.status, message: error.message }
    );
  }
  
  if (error instanceof ValidationError) {
    return new AIServiceError(
      'Response Validation Error',
      'VALIDATION_ERROR',
      { details: error.details }
    );
  }

  return new AIServiceError(
    'Unknown Error',
    'UNKNOWN_ERROR',
    { originalError: error }
  );
};

// example-usage.ts
const sentimentService = new SentimentAnalysisService();

try {
  const result = await sentimentService.analyzeSentiment(
    "The product exceeded my expectations!"
  );
  
  console.log('Analysis Result:', result);
  // {
  //   sentiment: "positive",
  //   confidence: 0.95,
  //   key_points: ["exceeded expectations"],
  //   suggested_actions: ["highlight in testimonials"]
  // }
} catch (error) {
  if (error instanceof AIServiceError) {
    // Handle specific error types
    handleServiceError(error);
  }
}

Implementation Notes