Trong quá trình xây dựng hệ thống AI tại production, tôi đã triển khai event bus cho hơn 50 dự án. Điều tôi nhận ra là: 80% các vấn đề nghiêm trọng không đến từ thuật toán AI mà từ cách chúng ta quản lý luồng dữ liệu API. Bài viết này sẽ hướng dẫn bạn thiết kế một event bus hoàn chỉnh với HolySheep AI — nền tảng tiết kiệm đến 85% chi phí so với API chính thức.

Bảng so sánh: HolySheep vs API chính thức vs Relay services

Tiêu chí HolySheep AI API chính thức Relay services thông thường
GPT-4.1 (per 1M tokens) $8 $60 $25-40
Claude Sonnet 4.5 $15 $90 $35-55
Gemini 2.5 Flash $2.50 $17.50 $8-12
DeepSeek V3.2 $0.42 $2.80 $1.20-1.80
Độ trễ trung bình <50ms 80-200ms 100-300ms
Thanh toán WeChat/Alipay/Tín dụng Chỉ thẻ quốc tế Hạn chế
Tín dụng miễn phí Có — khi đăng ký Không Ít khi
Event bus support Native + Batch API Không hỗ trợ Hạn chế

📌 Đăng ký tại đây để nhận tín dụng miễn phí và bắt đầu tiết kiệm ngay hôm nay.

Tại sao cần Event Bus cho AI API?

Trong thực chiến, tôi gặp rất nhiều vấn đề khi không có event bus:

Event bus giải quyết tất cả bằng cách tạo một layer trung gian quản lý luồng request/response.

Kiến trúc Event Bus hoàn chỉnh

1. Cấu trúc thư mục dự án

ai-event-bus/
├── src/
│   ├── bus/
│   │   ├── EventBus.ts           # Core event bus
│   │   ├── Queue.ts              # Priority queue
│   │   ├── RetryStrategy.ts      # Exponential backoff
│   │   └── LoadBalancer.ts       # Round-robin/Random
│   ├── handlers/
│   │   ├── OpenAIHandler.ts      # GPT handler
│   │   ├── AnthropicHandler.ts   # Claude handler
│   │   └── DeepSeekHandler.ts    # DeepSeek handler
│   ├── middleware/
│   │   ├── RateLimiter.ts        # Token bucket
│   │   ├── Cache.ts              # LRU cache
│   │   └── Logger.ts             # Structured logging
│   └── index.ts                  # Main entry
├── config/
│   └── providers.json            # Provider configs
├── package.json
└── tsconfig.json

2. Core Event Bus Implementation

// src/bus/EventBus.ts
import { EventEmitter } from 'events';
import { Queue } from './Queue';
import { RetryStrategy } from './RetryStrategy';
import { LoadBalancer } from './LoadBalancer';

interface AIRequest {
  id: string;
  model: 'gpt-4.1' | 'claude-sonnet-4.5' | 'gemini-2.5-flash' | 'deepseek-v3.2';
  messages: Array<{ role: string; content: string }>;
  temperature?: number;
  maxTokens?: number;
  priority?: number; // 1-10, cao hơn = ưu tiên hơn
  metadata?: Record;
}

interface AIResponse {
  id: string;
  model: string;
  content: string;
  usage: {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
  };
  latency: number;
  cost: number;
  timestamp: number;
}

type EventType = 'request' | 'response' | 'error' | 'retry' | 'rate_limit';

class AIEventBus extends EventEmitter {
  private queue: Queue;
  private retryStrategy: RetryStrategy;
  private loadBalancer: LoadBalancer;
  private baseUrl = 'https://api.holysheep.ai/v1';
  private apiKey: string;
  private metrics = {
    totalRequests: 0,
    successfulRequests: 0,
    failedRequests: 0,
    totalCost: 0,
    averageLatency: 0,
  };

  constructor(apiKey: string) {
    super();
    this.apiKey = apiKey;
    this.queue = new Queue();
    this.retryStrategy = new RetryStrategy({
      maxRetries: 3,
      baseDelay: 1000,
      maxDelay: 10000,
      factor: 2,
    });
    this.loadBalancer = new LoadBalancer(['us-east', 'eu-west', 'asia-pacific']);
    this.startProcessor();
  }

  async enqueue(request: AIRequest): Promise {
    const requestId = req_${Date.now()}_${Math.random().toString(36).substr(2, 9)};
    request.id = requestId;
    
    this.queue.enqueue(request, request.priority || 5);
    this.metrics.totalRequests++;
    
    this.emit('request', { requestId, model: request.model });
    
    console.log([EventBus] Enqueued request ${requestId} with priority ${request.priority || 5});
    
    return requestId;
  }

  private async processRequest(request: AIRequest): Promise {
    const startTime = Date.now();
    
    try {
      // Map model names to HolySheep compatible format
      const modelMap: Record = {
        'gpt-4.1': 'gpt-4.1',
        'claude-sonnet-4.5': 'claude-sonnet-4.5',
        'gemini-2.5-flash': 'gemini-2.5-flash',
        'deepseek-v3.2': 'deepseek-v3.2',
      };

      const endpoint = this.loadBalancer.getNext();
      const url = ${this.baseUrl}/chat/completions;
      
      const response = await fetch(url, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': Bearer ${this.apiKey},
          'X-Region': endpoint,
        },
        body: JSON.stringify({
          model: modelMap[request.model],
          messages: request.messages,
          temperature: request.temperature ?? 0.7,
          max_tokens: request.maxTokens ?? 2048,
        }),
      });

      if (!response.ok) {
        const error = await response.text();
        throw new Error(API Error ${response.status}: ${error});
      }

      const data = await response.json();
      const latency = Date.now() - startTime;
      
      // Calculate cost based on actual usage
      const cost = this.calculateCost(request.model, data.usage);
      
      const aiResponse: AIResponse = {
        id: request.id,
        model: request.model,
        content: data.choices?.[0]?.message?.content || '',
        usage: data.usage,
        latency,
        cost,
        timestamp: Date.now(),
      };

      this.metrics.successfulRequests++;
      this.metrics.totalCost += cost;
      this.metrics.averageLatency = 
        (this.metrics.averageLatency * (this.metrics.successfulRequests - 1) + latency) 
        / this.metrics.successfulRequests;

      this.emit('response', aiResponse);
      
      return aiResponse;

    } catch (error: any) {
      this.metrics.failedRequests++;
      this.emit('error', { request, error: error.message });
      throw error;
    }
  }

  private calculateCost(model: string, usage: any): number {
    const pricing: Record = {
      'gpt-4.1': { input: 8, output: 8 },           // $8/1M tokens
      'claude-sonnet-4.5': { input: 15, output: 15 }, // $15/1M tokens
      'gemini-2.5-flash': { input: 2.50, output: 2.50 }, // $2.50/1M tokens
      'deepseek-v3.2': { input: 0.42, output: 0.42 }, // $0.42/1M tokens
    };

    const p = pricing[model] || { input: 0, output: 0 };
    const inputCost = (usage.prompt_tokens / 1000000) * p.input;
    const outputCost = (usage.completion_tokens / 1000000) * p.output;
    
    return inputCost + outputCost;
  }

  private startProcessor(): void {
    setInterval(async () => {
      const request = this.queue.dequeue();
      if (request) {
        await this.processWithRetry(request);
      }
    }, 100); // Process every 100ms
  }

  private async processWithRetry(request: AIRequest): Promise {
    const retryConfig = this.retryStrategy.getConfig();
    
    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
      try {
        await this.processRequest(request);
        return;
      } catch (error: any) {
        if (attempt === retryConfig.maxRetries) {
          console.error([EventBus] Max retries reached for ${request.id});
          throw error;
        }

        const delay = this.retryStrategy.calculateDelay(attempt);
        console.log([EventBus] Retrying ${request.id} in ${delay}ms (attempt ${attempt + 1}));
        
        this.emit('retry', { request, attempt: attempt + 1, delay });
        
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }

  getMetrics() {
    return {
      ...this.metrics,
      queueSize: this.queue.size(),
      successRate: this.metrics.totalRequests > 0 
        ? (this.metrics.successfulRequests / this.metrics.totalRequests * 100).toFixed(2) + '%'
        : '0%',
    };
  }
}

export { AIEventBus, AIRequest, AIResponse, EventType };

3. Priority Queue với Token Bucket Rate Limiter

// src/bus/Queue.ts
interface QueueItem {
  item: T;
  priority: number;
  timestamp: number;
}

class Queue {
  private items: QueueItem[] = [];
  private maxSize: number;

  constructor(maxSize = 10000) {
    this.maxSize = maxSize;
  }

  enqueue(item: T, priority: number): boolean {
    if (this.items.length >= this.maxSize) {
      // Evict lowest priority item
      const lowestIdx = this.findLowestPriorityIndex();
      if (lowestIdx !== -1 && priority > this.items[lowestIdx].priority) {
        this.items.splice(lowestIdx, 1);
      } else {
        return false;
      }
    }

    const queueItem: QueueItem = {
      item,
      priority,
      timestamp: Date.now(),
    };

    // Insert based on priority (higher priority first, then FIFO)
    let inserted = false;
    for (let i = 0; i < this.items.length; i++) {
      if (priority > this.items[i].priority || 
          (priority === this.items[i].priority && queueItem.timestamp < this.items[i].timestamp)) {
        this.items.splice(i, 0, queueItem);
        inserted = true;
        break;
      }
    }

    if (!inserted) {
      this.items.push(queueItem);
    }

    return true;
  }

  private findLowestPriorityIndex(): number {
    let lowestPriority = Infinity;
    let lowestIdx = -1;
    let oldestTimestamp = Infinity;

    for (let i = 0; i < this.items.length; i++) {
      if (this.items[i].priority < lowestPriority ||
          (this.items[i].priority === lowestPriority && 
           this.items[i].timestamp < oldestTimestamp)) {
        lowestPriority = this.items[i].priority;
        lowestIdx = i;
        oldestTimestamp = this.items[i].timestamp;
      }
    }

    return lowestIdx;
  }

  dequeue(): T | undefined {
    return this.items.shift()?.item;
  }

  peek(): T | undefined {
    return this.items[0]?.item;
  }

  size(): number {
    return this.items.length;
  }

  clear(): void {
    this.items = [];
  }
}

// Token Bucket Rate Limiter
class TokenBucketRateLimiter {
  private tokens: number;
  private lastRefill: number;
  private bucketCapacity: number;
  private refillRate: number; // tokens per second

  constructor(capacity: number, refillRate: number) {
    this.bucketCapacity = capacity;
    this.tokens = capacity;
    this.refillRate = refillRate;
    this.lastRefill = Date.now();
  }

  async acquire(tokensNeeded = 1): Promise {
    this.refill();

    if (this.tokens >= tokensNeeded) {
      this.tokens -= tokensNeeded;
      return true;
    }

    // Wait until tokens are available
    const tokensNeededToWait = tokensNeeded - this.tokens;
    const waitTimeMs = (tokensNeededToWait / this.refillRate) * 1000;
    
    await new Promise(resolve => setTimeout(resolve, waitTimeMs));
    this.refill();
    
    this.tokens -= tokensNeeded;
    return true;
  }

  private refill(): void {
    const now = Date.now();
    const elapsed = (now - this.lastRefill) / 1000;
    const tokensToAdd = elapsed * this.refillRate;
    
    this.tokens = Math.min(this.bucketCapacity, this.tokens + tokensToAdd);
    this.lastRefill = now;
  }

  getAvailableTokens(): number {
    this.refill();
    return Math.floor(this.tokens);
  }
}

export { Queue, TokenBucketRateLimiter };

4. Retry Strategy với Circuit Breaker

// src/bus/RetryStrategy.ts
interface RetryConfig {
  maxRetries: number;
  baseDelay: number;
  maxDelay: number;
  factor: number;
}

class RetryStrategy {
  private config: RetryConfig;
  private circuitBreakerState: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  private failureCount = 0;
  private successCount = 0;
  private lastFailureTime = 0;
  private threshold = 5; // failures before opening circuit
  private resetTimeout = 60000; // 60 seconds

  constructor(config: RetryConfig) {
    this.config = config;
  }

  getConfig(): RetryConfig {
    return { ...this.config };
  }

  calculateDelay(attempt: number): number {
    // Exponential backoff with jitter
    const exponentialDelay = this.config.baseDelay * Math.pow(this.config.factor, attempt);
    const jitter = Math.random() * 0.3 * exponentialDelay;
    const delay = Math.min(exponentialDelay + jitter, this.config.maxDelay);
    
    return Math.round(delay);
  }

  // Circuit Breaker methods
  recordSuccess(): void {
    this.successCount++;
    this.failureCount = 0;
    
    if (this.circuitBreakerState === 'HALF_OPEN' && this.successCount >= 3) {
      this.circuitBreakerState = 'CLOSED';
      console.log('[CircuitBreaker] Circuit closed - service recovered');
    }
  }

  recordFailure(): void {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.threshold) {
      this.circuitBreakerState = 'OPEN';
      console.log('[CircuitBreaker] Circuit opened - preventing calls');
    }
  }

  canExecute(): boolean {
    if (this.circuitBreakerState === 'CLOSED') {
      return true;
    }

    if (this.circuitBreakerState === 'OPEN') {
      const timeSinceFailure = Date.now() - this.lastFailureTime;
      
      if (timeSinceFailure >= this.resetTimeout) {
        this.circuitBreakerState = 'HALF_OPEN';
        this.successCount = 0;
        console.log('[CircuitBreaker] Circuit half-open - testing service');
        return true;
      }
      
      return false;
    }

    // HALF_OPEN - allow limited requests
    return true;
  }

  getState(): string {
    return this.circuitBreakerState;
  }
}

export { RetryStrategy, RetryConfig };

5. Load Balancer cho Multi-Region

// src/bus/LoadBalancer.ts
type Strategy = 'round-robin' | 'least-latency' | 'random';

class LoadBalancer {
  private regions: string[];
  private currentIndex = 0;
  private latencyMap: Map = new Map();
  private requestCount: Map = new Map();
  private strategy: Strategy;

  constructor(regions: string[], strategy: Strategy = 'round-robin') {
    this.regions = regions;
    this.strategy = strategy;
    
    regions.forEach(region => {
      this.latencyMap.set(region, Infinity);
      this.requestCount.set(region, 0);
    });
  }

  getNext(): string {
    switch (this.strategy) {
      case 'round-robin':
        return this.roundRobin();
      case 'least-latency':
        return this.leastLatency();
      case 'random':
        return this.random();
      default:
        return this.roundRobin();
    }
  }

  private roundRobin(): string {
    const region = this.regions[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.regions.length;
    this.requestCount.set(region, (this.requestCount.get(region) || 0) + 1);
    return region;
  }

  private leastLatency(): string {
    let bestRegion = this.regions[0];
    let bestLatency = this.latencyMap.get(bestRegion) || Infinity;

    for (const region of this.regions) {
      const latency = this.latencyMap.get(region) || Infinity;
      if (latency < bestLatency) {
        bestLatency = latency;
        bestRegion = region;
      }
    }

    this.requestCount.set(bestRegion, (this.requestCount.get(bestRegion) || 0) + 1);
    return bestRegion;
  }

  private random(): string {
    const region = this.regions[Math.floor(Math.random() * this.regions.length)];
    this.requestCount.set(region, (this.requestCount.get(region) || 0) + 1);
    return region;
  }

  updateLatency(region: string, latency: number): void {
    // Weighted moving average
    const currentLatency = this.latencyMap.get(region) || latency;
    this.latencyMap.set(region, currentLatency * 0.7 + latency * 0.3);
  }

  getStats(): Record {
    const stats: Record = {};
    
    for (const region of this.regions) {
      stats[region] = {
        latency: Math.round(this.latencyMap.get(region) || 0),
        requests: this.requestCount.get(region) || 0,
      };
    }
    
    return stats;
  }
}

export { LoadBalancer, Strategy };

Cách sử dụng trong thực tế

// Ví dụ sử dụng hoàn chỉnh
import { AIEventBus } from './src/bus/EventBus';

const eventBus = new AIEventBus('YOUR_HOLYSHEEP_API_KEY');

// Subscribe to events for monitoring
eventBus.on('response', (response) => {
  console.log([Monitor] ${response.model} - ${response.latency}ms - $${response.cost.toFixed(6)});
});

eventBus.on('error', ({ request, error }) => {
  console.error([Error] Request ${request.id} failed: ${error});
});

eventBus.on('retry', ({ request, attempt, delay }) => {
  console.log([Retry] ${request.id} - attempt ${attempt}, waiting ${delay}ms);
});

// Enqueue requests with different priorities
async function processUserRequests() {
  // High priority request (user interaction)
  const highPriorityId = await eventBus.enqueue({
    id: '',
    model: 'gpt-4.1',
    messages: [{ role: 'user', content: 'Summarize this article' }],
    temperature: 0.3,
    maxTokens: 500,
    priority: 10, // Highest priority
  });

  // Batch processing (background job)
  const batchId = await eventBus.enqueue({
    id: '',
    model: 'deepseek-v3.2',
    messages: [{ role: 'user', content: 'Translate 1000 product descriptions' }],
    temperature: 0.2,
    maxTokens: 10000,
    priority: 3, // Lower priority
  });

  // Get metrics
  console.log('System metrics:', eventBus.getMetrics());
}

processUserRequests();

Tính năng nâng cao

1. Model Fallback tự động

// Model fallback chain - khi model chính fail, tự động chuyển sang model dự phòng
const modelFallbackChain: Record = {
  'gpt-4.1': ['claude-sonnet-4.5', 'gemini-2.5-flash', 'deepseek-v3.2'],
  'claude-sonnet-4.5': ['gpt-4.1', 'gemini-2.5-flash', 'deepseek-v3.2'],
  'gemini-2.5-flash': ['gpt-4.1', 'claude-sonnet-4.5', 'deepseek-v3.2'],
};

async function smartFallback(request: AIRequest): Promise {
  const fallbackModels = modelFallbackChain[request.model] || [];
  
  for (const model of [request.model, ...fallbackModels]) {
    try {
      const response = await eventBus.enqueue({
        ...request,
        model: model as any,
        priority: request.priority || 5,
      });
      
      console.log([Fallback] Success with ${model});
      return response;
    } catch (error) {
      console.warn([Fallback] ${model} failed, trying next...);
      continue;
    }
  }
  
  throw new Error('All models in fallback chain failed');
}

2. Streaming với Server-Sent Events

// Streaming endpoint cho real-time responses
async function* streamAIResponse(
  messages: Array<{ role: string; content: string }>,
  model: string
): AsyncGenerator {
  const response = await fetch(${BASE_URL}/chat/completions, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': Bearer ${API_KEY},
    },
    body: JSON.stringify({
      model,
      messages,
      stream: true,
    }),
  });

  const reader = response.body?.getReader();
  const decoder = new TextDecoder();

  while (reader) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n').filter(line => line.trim() !== '');

    for (const line of lines) {
      if (line.startsWith('data: ')) {
        const data = JSON.parse(line.slice(6));
        if (data.choices?.[0]?.delta?.content) {
          yield data.choices[0].delta.content;
        }
      }
    }
  }
}

// Usage
async function main() {
  for await (const token of streamAIResponse(
    [{ role: 'user', content: 'Write a story' }],
    'gpt-4.1'
  )) {
    process.stdout.write(token);
  }
}

Lỗi thường gặp và cách khắc phục

1. Lỗi 401 Unauthorized - API Key không hợp lệ

// ❌ SAI: API key bị rò rỉ hoặc sai format
const API_KEY = 'sk-xxxxxxxxxxxxx'; // Key cũ từ OpenAI

// ✅ ĐÚNG: Sử dụng key từ HolySheep
const API_KEY = 'YOUR_HOLYSHEEP_API_KEY'; // Từ dashboard HolySheep
const BASE_URL = 'https://api.holysheep.ai/v1';

// Kiểm tra key hợp lệ
async function validateApiKey(key: string): Promise {
  try {
    const response = await fetch(${BASE_URL}/models, {
      headers: {
        'Authorization': Bearer ${key},
      },
    });
    return response.ok;
  } catch {
    return false;
  }
}

// Sử dụng key từ environment variable
import dotenv from 'dotenv';
dotenv.config();

const apiKey = process.env.HOLYSHEEP_API_KEY;
if (!apiKey) {
  throw new Error('HOLYSHEEP_API_KEY not set in environment');
}

Nguyên nhân: Key từ OpenAI/Anthropic không hoạt động với HolySheep endpoint.

Khắc phục: Lấy API key từ dashboard HolySheep AI và đảm bảo format đúng.

2. Lỗi 429 Rate Limit Exceeded

// ❌ SAI: Gửi request liên tục không kiểm soát
async function badImplementation() {
  const requests = Array(100).fill({ messages: [{ role: 'user', content: 'Hi' }] });
  
  for (const req of requests) {
    await fetch(${BASE_URL}/chat/completions, { /* ... */ }); // Sẽ bị rate limit ngay
  }
}

// ✅ ĐÚNG: Sử dụng rate limiter và exponential backoff
import { TokenBucketRateLimiter } from './src/bus/Queue';

const rateLimiter = new TokenBucketRateLimiter(100, 10); // 100 tokens, refill 10/second

async function goodImplementation() {
  const requests = Array(100).fill({ messages: [{ role: 'user', content: 'Hi' }] });
  
  const promises = requests.map(async (req) => {
    await rateLimiter.acquire(1); // Chờ đến khi có quota
    
    const response = await fetch(${BASE_URL}/chat/completions, {
      method: 'POST',
      headers: {
        'Authorization': Bearer ${API_KEY},
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'gpt-4.1',
        messages: req.messages,
      }),
    });
    
    if (response.status === 429) {
      // Retry sau khi có Retry-After header
      const retryAfter = response.headers.get('Retry-After') || 60;
      await new Promise(r => setTimeout(r, retryAfter * 1000));
      return goodImplementation(); // Recursive retry
    }
    
    return response.json();
  });
  
  return Promise.allSettled(promises);
}

// Batch processing thay vì gửi từng request
async function batchProcess(messages: string[]) {
  // Group thành batch 20 requests
  const batchSize = 20;
  const batches = [];
  
  for (let i = 0; i < messages.length; i += batchSize) {
    batches.push(messages.slice(i, i + batchSize));
  }
  
  for (const batch of batches) {
    await Promise.all(batch.map(msg => rateLimiter.acquire(1)));
    console.log(Processed batch of ${batch.length} requests);
    await new Promise(r => setTimeout(r, 1000)); // Delay giữa các batch
  }
}

Nguyên nhân: Quá nhiều request trong thời gian ngắn, vượt quá rate limit của API.

Khắc phục: Sử dụng Token Bucket algorithm, implement exponential backoff, và batch requests khi có thể.

3. Lỗi 500 Internal Server Error hoặc 503 Service Unavailable

// ❌ SAI: Không có fallback, request bị fail hoàn toàn
async function noFallback() {
  const response = await fetch(${BASE_URL}/chat/completions, {
    method: 'POST',
    body: JSON.stringify({ /* ... */ }),
  });
  
  if (!response.ok) {
    throw new Error('API failed'); // User nhận error
  }
}

// ✅ ĐÚNG: Implement circuit breaker và multi-provider fallback
import { RetryStrategy } from './src/bus/RetryStrategy';
import { LoadBalancer } from './src/bus/LoadBalancer';

const retryStrategy = new RetryStrategy({
  maxRetries: 3,
  baseDelay: 1000,
  maxDelay: 10000,
  factor: 2,
});

const loadBalancer = new LoadBalancer(['primary', 'secondary', 'tertiary']);

// Provider configs với fallback
const providers = [
  { name: 'holysheep', url: 'https://api.holysheep.ai/v1', priority: 1 },
  { name: 'backup-provider', url: 'https://backup-api.example.com/v1', priority: 2 },
];

async function resilientRequest(messages: any[], model: string) {
  if (!retryStrategy.canExecute()) {
    throw new Error('Circuit breaker is open - service unavailable');
  }
  
  for (const provider of providers) {
    try {
      const response = await fetchWithTimeout(
        ${provider.url}/chat/completions,
        {
          method: 'POST',
          headers: {
            'Authorization': Bearer ${API_KEY},
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ model, messages }),
        },
        30000 //

Tài nguyên liên quan
Bài viết liên quan