History Playback

curl -X GET "https://vas-poc.vurbo.ai/api/v1/tasks" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "tasks": [
    {
      "task_id": "550e8400-e29b-41d4-a716-446655440000",
      "title": "Product Planning Meeting",
      "type": "transcribe",
      "duration_ms": 3600000,
      "duration_formatted": "60:00",
      "source_lang": "zh-TW",
      "target_lang": "en-US",
      "created_at": "2026-02-20T10:00:00Z",
      "is_pinned": false,
      "is_unread": true
    }
  ]
}

const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/history/transcribe/${taskId}`,
  {
    headers: { 'X-API-Key': apiKey }
  }
);

connected → init_metadata → init_sentence × N → init_summary → init_done

event: connected
data: {"message": "History service connected (recordingId: xxx)"}

event: init_metadata
data: {"task_id": "550e8400...", "title": "Meeting Notes", "created_at": "2026-02-20T10:00:00Z", "type": "transcribe", "has_speaker_diarization": false, "transcription_languages": ["zh-TW"], "translation_languages": ["en-US"], "summary_template": "general", "summary_language": "zh-TW"}

event: init_sentence
data: {"sid": 1, "origin": "你好，很高興認識你", "translations": {"en-US": "Hello, nice to meet you"}, "start_time": "00:05", "speaker_id": "0"}

event: init_sentence
data: {"sid": 5, "origin": "敏感詞句子", "translations": {"en-US": "Sensitive sentence"}, "translation_errors": {"ja": "llm_content_filtered"}, "start_time": "00:25", "speaker_id": "0"}

event: init_summary
data: {"text": "This is a summary of the meeting notes..."}

event: init_done
data: {"totalSentences": 42}

async function loadHistory(taskId, apiKey) {
  const response = await fetch(
    `https://vas-poc.vurbo.ai/api/v1/sse/history/transcribe/${taskId}`,
    { headers: { 'X-API-Key': apiKey } }
  );

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';

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

    buffer += decoder.decode(value, { stream: true });

    // Parse SSE format (events are separated by double newlines)
    const events = buffer.split('\n\n');
    buffer = events.pop(); // The last segment may be incomplete

    for (const eventStr of events) {
      const lines = eventStr.split('\n');
      let eventType = '';
      let eventData = '';

      for (const line of lines) {
        if (line.startsWith('event: ')) eventType = line.slice(7);
        if (line.startsWith('data: ')) eventData = line.slice(6);
      }

      if (!eventType || !eventData) continue;
      const data = JSON.parse(eventData);

      switch (eventType) {
        case 'init_metadata':
          console.log(`Task: ${data.title} (${data.type})`);
          break;
        case 'init_sentence':
          console.log(`[${data.start_time}] ${data.origin}`);
          if (data.translation) {
            console.log(`  → ${data.translation}`);
          }
          break;
        case 'init_summary':
          console.log(`Summary: ${data.text}`);
          break;
        case 'init_done':
          console.log(`Load complete, ${data.totalSentences} sentences total`);
          break;
      }
    }
  }
}

async function playAudio(taskId, apiKey) {
  const response = await fetch(
    `https://vas-poc.vurbo.ai/api/v1/sse/audio/${taskId}`,
    { headers: { 'X-API-Key': apiKey } }
  );
  const blob = await response.blob();
  const audioUrl = URL.createObjectURL(blob);
  const audio = new Audio(audioUrl);
  audio.play();
}

Content-Type: audio/mp4      (all recording audio files are returned in an M4A container)
Content-Length: 1234567
Accept-Ranges: bytes

const audio = document.createElement('audio');
audio.src = `https://vas-poc.vurbo.ai/api/v1/sse/audio/${taskId}`;
// The browser will automatically include X-API-Key... but extra handling is needed

// Recommended: use the Blob URL approach
const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/audio/${taskId}`,
  { headers: { 'X-API-Key': apiKey } }
);
const blob = await response.blob();
audio.src = URL.createObjectURL(blob);
audio.controls = true;
document.body.appendChild(audio);

GET /api/v1/sse/retranslate/{taskId}?targetLang=ja-JP

const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/retranslate/${taskId}?targetLang=ja-JP`,
  { headers: { 'X-API-Key': apiKey } }
);

translation × N → done

event: translation
data: {"sid": 1, "text": "こんにちは、お会いできて嬉しいです", "is_final": true}

event: done
data: {"totalUpdated": 42}

async function retranslate(taskId, targetLang, apiKey) {
  const response = await fetch(
    `https://vas-poc.vurbo.ai/api/v1/sse/retranslate/${taskId}?targetLang=${targetLang}`,
    { headers: { 'X-API-Key': apiKey } }
  );

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';

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

    buffer += decoder.decode(value, { stream: true });
    const events = buffer.split('\n\n');
    buffer = events.pop();

    for (const eventStr of events) {
      const lines = eventStr.split('\n');
      let eventType = '';
      let eventData = '';

      for (const line of lines) {
        if (line.startsWith('event: ')) eventType = line.slice(7);
        if (line.startsWith('data: ')) eventData = line.slice(6);
      }

      if (!eventType || !eventData) continue;
      const data = JSON.parse(eventData);

      if (eventType === 'translation') {
        // Update the translation for the matching sid in the UI
        updateTranslation(data.sid, data.text);
      } else if (eventType === 'done') {
        console.log(`Retranslation complete, ${data.totalUpdated} sentences updated`);
      }
    }
  }
}

GET /api/v1/sse/retranslate/summary/{taskId}?targetLang=ja-JP

const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/retranslate/summary/${taskId}?targetLang=ja-JP`,
  { headers: { 'X-API-Key': apiKey } }
);

summary_translation × N → done

event: summary_translation
data: {"text": "Accumulated translation result...", "is_final": false}

event: done
data: {"totalUpdated": 1}

// Single-sentence playback
const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/tts/${taskId}?language=en-US&sid=1`,
  { headers: { 'X-API-Key': apiKey } }
);

// Multi-sentence playback (start from sentence 5, play 3 sentences)
const response = await fetch(
  `https://vas-poc.vurbo.ai/api/v1/sse/tts/${taskId}?language=en-US&sid=5&length=3`,
  { headers: { 'X-API-Key': apiKey } }
);

connected → tts_audio × N → tts_done

event: tts_audio
data: {"sid": 5, "transcript": "你好", "text": "Hello", "audio": "Base64...", "duration_ms": 2500, "boundaries": [...]}

event: tts_done
data: {"sentences_sent": 3, "total_duration_ms": 7500}

async function playTTS(taskId, language, sid, length, apiKey) {
  const url = new URL(`https://vas-poc.vurbo.ai/api/v1/sse/tts/${taskId}`);
  url.searchParams.set('language', language);
  url.searchParams.set('sid', sid);
  url.searchParams.set('length', length);

  const response = await fetch(url, {
    headers: { 'X-API-Key': apiKey }
  });

  // Play the audio after parsing the SSE events
  // ...(SSE parsing logic same as above)

  // When a tts_audio event is received:
  function handleTTSAudio(data) {
    const binaryString = atob(data.audio);
    const bytes = new Uint8Array(binaryString.length);
    for (let i = 0; i < binaryString.length; i++) {
      bytes[i] = binaryString.charCodeAt(i);
    }
    const blob = new Blob([bytes], { type: 'audio/mp3' });
    const audio = new Audio(URL.createObjectURL(blob));
    audio.play();
  }
}

                ┌──────────────────┐
                │  GET /api/v1/tasks │  Get task list
                └────────┬─────────┘
                         │
                    Select task_id
                         │
        ┌────────────────┼────────────────┐
        │                │                │
  ┌─────▼──────┐   ┌────▼─────┐   ┌─────▼──────┐
  │ Load        │   │ Audio    │   │ Retranslate│
  │ transcript  │   │ playback │   │            │
  │ SSE History │   │ Audio API│   │SSE Retrans.│
  └─────┬──────┘   └────┬─────┘   └─────┬──────┘
        │                │                │
        │          ┌─────▼──────┐         │
        │          │  HTTP 200  │         │
        │          │  Audio     │         │
        │          │  stream    │         │
        │          │ (Range OK) │         │
        │          └────────────┘         │
        │                                 │
  ┌─────▼──────────────────┐   ┌─────────▼────────┐
  │ SSE event sequence:    │   │ SSE event seq.:   │
  │                        │   │                   │
  │ 1. connected           │   │ translation × N   │
  │ 2. init_metadata       │   │ done              │
  │ 3. init_sentence × N   │   └───────────────────┘
  │ 4. init_summary        │
  │ 5. init_done           │         ┌──────────────────┐
  └────────────────────────┘         │ Summary retrans. │
                                     │ SSE Retrans/Summary│
                                     └────────┬─────────┘
                                              │
                                     summary_translation × N
                                     done
                         │
                ┌────────▼─────────┐
                │  TTS playback     │
                │  SSE /tts/{id}   │
                └────────┬─────────┘
                         │
                connected → tts_audio × N → tts_done

1. Call GET /api/v1/tasks to get the task list
2. The user selects a task
3. Call these concurrently:
   a. SSE History API to load the transcript (render each init_sentence as it arrives)
   b. Audio API to prepare audio playback
4. The user can:
   - Play / seek the audio
   - Switch the translation language (call SSE Retranslate)
   - Switch the summary language (call SSE Retranslate Summary)
   - Switch the summary template to regenerate (call SSE Regenerate Summary)
   - Play the translated TTS audio (call SSE TTS)