गलतियाँ

API एरर रिस्पॉन्स, WebSocket क्लोज़ कोड और उन्हें कैसे हैंडल करें, यह समझना

REST API एरर फ़ॉर्मैट (HTTP)

जब किसी स्टैंडर्ड HTTP एंडपॉइंट पर कोई एरर आता है, तो API नीचे दिए गए स्ट्रक्चर वाला JSON रिस्पॉन्स देता है:

{
    "success": false,
    "error": {
        "code": "ERROR_CODE",
        "message": "इंसानों के पढ़ने लायक़ एरर का विवरण",
        "details": {
          // अतिरिक्त संदर्भ (त्रुटि के प्रकार के अनुसार अलग-अलग)
        }
    }
}

WebSocket एरर फ़ॉर्मैट (WSS)

WebSockets में एरर को अलग तरह से हैंडल किया जाता है। शुरुआती कनेक्शन हैंडशेक के दौरान या ऑडियो जनरेट होने के दौरान बीच में एरर आ सकते हैं।

• गंभीर त्रुटियाँ: कनेक्शन को एक खास क्लोज़ कोड (जैसे, 4290) के साथ बंद कर दिया जाता है।
• प्रक्रिया के बीच में आने वाली त्रुटियाँ: सर्वर बंद होने से पहले एक फ़्लैट JSON एरर फ़्रेम भेजता है: {"error": "स्ट्रीम के दौरान अपर्याप्त क्रेडिट"}

स्टेटस कोड और क्लोज़ कोड

HTTP स्टेटस कोड (REST)

WebSocket क्लोज़ कोड (WSS)

गलती होने की आम स्थितियाँ

1. अनऑथराइज़्ड / ऑथेंटिकेशन फ़ेल

API की (key) न होने या गलत होने, या IP व्हाइटलिस्ट पाबंदियों की वजह से ऑथेंटिकेशन फेल हो गया।

आम कारण:

• Authorization: Bearer हेडर मौजूद नहीं है
• API की का फ़ॉर्मैट गलत है या की को रद्द कर दिया गया है।
• ऐसे IP एड्रेस से कनेक्ट करना जो आपकी की (key) की व्हाइटलिस्ट में नहीं है

2. अपर्याप्त क्रेडिट

इस अनुरोध को पूरा करने के लिए आपके खाते में पर्याप्त क्रेडिट नहीं हैं।

• HTTP: ऑडियो जनरेट होने से ठीक पहले फ़ेल हो जाता है।
• वेब-सॉकेट: अगर स्ट्रीमिंग के बीच में आपके क्रेडिट खत्म हो जाते हैं, तो सर्वर भेजता है {"error": "स्ट्रीम के दौरान अपर्याप्त क्रेडिट"} और कनेक्शन को सही तरीके से बंद कर देता है। क्रेडिट खत्म होने से पहले जो ऑडियो बना था, वह भी डिलीवर किया जाएगा।

3. कॉन्करेंसी और रेट लिमिट्स

सही इस्तेमाल सुनिश्चित करने के लिए, Moknah एक बार में हर यूज़र की एक ही रिक्वेस्ट प्रोसेस करता है।

• HTTP 409: आपके अकाउंट से एक और रिक्वेस्ट पर पहले से ही काम चल रहा है। उसके पूरा होने का इंतज़ार करें।
• HTTP 429: आपने 60 रिक्वेस्ट प्रति मिनट (RPM) की सीमा पार कर ली है।
• WSS 4290: आपने तब दूसरा WebSocket कनेक्शन खोलने की कोशिश की, जब आपका पहला कनेक्शन अभी भी चालू था।

4. अमान्य अनुरोध / खराब डेटा

रिक्वेस्ट पैरामीटर अमान्य हैं, या आपने टेक्स्ट चंक की सीमा पार कर ली है।

• HTTP: ज़रूरी फ़ील्ड (text, voice_id) मौजूद नहीं हैं।
• वेब-सॉकेट: 2,000 कैरेक्टर से ज़्यादा लंबा टेक्स्ट भेजने पर {"error": "हिस्सा बहुत बड़ा है। हर हिस्से में ज़्यादा से ज़्यादा 2000 कैरेक्टर हो सकते हैं।"}.

कोड में एरर को संभालना

import requests
import time

def generate_speech(text, voice_id, api_key):
    url = "https://moknah.io/api/v1/tts/generate"
    headers = {"Authorization": f"Bearer {api_key}"}

    response = requests.post(url, json={"text": text, "voice_id": voice_id}, headers=headers)

    if response.status_code == 200:
        return response.content  # ऑडियो बाइट्स
    elif response.status_code == 402:
        raise Exception("अपर्याप्त क्रेडिट")
    elif response.status_code == 429:
        retry_after = int(response.headers.get("Retry-After", 5))
        time.sleep(retry_after)
        return generate_speech(text, voice_id, api_key)  # फिर से कोशिश करें
    elif response.status_code == 409:
        time.sleep(5)
        return generate_speech(text, voice_id, api_key)  # फिर से कोशिश करें
    else:
        raise Exception(f"API error: {response.status_code}")

async function generateSpeech(text, voiceId, apiKey) {
  const response = await fetch("https://moknah.io/api/v1/tts/generate", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ text: text, voice_id: voiceId })
  });

  if (response.ok) return await response.blob();

  if (response.status === 429) {
    const retryAfter = response.headers.get("Retry-After") || 5;
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return generateSpeech(text, voiceId, apiKey);
  }

  if (response.status === 409) {
    await new Promise(r => setTimeout(r, 5000));
    return generateSpeech(text, voiceId, apiKey);
  }

  const error = await response.json();
  throw new Error(error.error?.message || "API Error");
}

const ws = new WebSocket('wss://moknah.io/api/v1/api/v1/tts/ws/', {
    headers: { "Authorization": `Bearer ${apiKey}` }
});

// Handle Mid-Stream JSON Errors
ws.on('message', (data, isBinary) => {
    if (!isBinary) {
        const msg = JSON.parse(data.toString());
        if (msg.error) {
            console.error("Stream Error:", msg.error);
            // e.g., "Insufficient credits during stream"
        }
    }
});

// Handle Fatal Close Codes
ws.on('close', (code, reason) => {
    switch(code) {
        case 1000:
            console.log("Stream finished successfully.");
            break;
        case 4001:
        case 4002:
            console.error("Authentication failed. Check your API key.");
            break;
        case 4290:
            console.error("Concurrency limit reached. Close other active streams.");
            // Wait a few seconds before attempting to reconnect
            setTimeout(reconnect, 5000);
            break;
        case 3011:
            console.error("Upstream generation failed. Please try again.");
            break;
        default:
            console.error(`Disconnected with code ${code}`);
    }
});