Gửi request tạo nội dung
        ↓
Nhận task_id
        ↓
Kiểm tra trạng thái task
        ↓
SUCCESS: sử dụng kết quả
FAILURE: xử lý lỗi

https://api.notexapp.com

-H "X-API-Key: ntx_live_..."

GET /v1/create/tasks/{task_id}/result

curl https://api.notexapp.com/v1/create/tasks/task_123456/result \
  -H "X-API-Key: ntx_live_..."

{
  "status": "PROCESSING",
  "step": "transcribing",
  "progress": 35,
  "estimated_time": 60
}

{
  "status": "PROCESSING"
}

{
  "status": "SUCCESS",
  "data": {
    "note_id": "665f...",
    "title": "Introduction to Machine Learning",
    "summary": "An overview of machine learning concepts..."
  }
}

{
  "status": "FAILURE",
  "error": "Unsupported file format",
  "error_key": "unsupported_file_format",
  "message": "The uploaded file format is not supported."
}

TASK_ID="task_123456"

while true; do
  RESPONSE=$(curl -s \
    "https://api.notexapp.com/v1/create/tasks/$TASK_ID/result" \
    -H "X-API-Key: ntx_live_...")

  STATUS=$(echo "$RESPONSE" | jq -r '.status')

  if [ "$STATUS" = "SUCCESS" ]; then
    echo "$RESPONSE"
    break
  fi

  if [ "$STATUS" = "FAILURE" ] || [ "$STATUS" = "FAIL" ]; then
    echo "$RESPONSE" >&2
    exit 1
  fi

  sleep 5
done

type TaskStatus =
  | 'PENDING'
  | 'PROCESSING'
  | 'SUCCESS'
  | 'FAILURE'
  | 'FAIL';

interface TaskProcessingResponse {
  status: 'PENDING' | 'PROCESSING';
  step?: string;
  progress?: number;
  estimated_time?: number;
}

interface TaskSuccessResponse<T> {
  status: 'SUCCESS';
  data: T;
  message?: string;
}

interface TaskFailureResponse {
  status: 'FAILURE' | 'FAIL';
  error?: string;
  error_key?: string;
  message?: string;
}

type TaskResultResponse<T> =
  | TaskProcessingResponse
  | TaskSuccessResponse<T>
  | TaskFailureResponse;

interface PollTaskOptions {
  intervalMs?: number;
  timeoutMs?: number;
  signal?: AbortSignal;
  onProgress?: (task: TaskProcessingResponse) => void;
}

async function pollTask<T>(
  taskId: string,
  apiKey: string,
  options: PollTaskOptions = {},
): Promise<T> {
  const {
    intervalMs = 4000,
    timeoutMs = 120000,
    signal,
    onProgress,
  } = options;

  const startedAt = Date.now();

  while (Date.now() - startedAt < timeoutMs) {
    if (signal?.aborted) {
      throw new DOMException('Task polling was cancelled', 'AbortError');
    }

    const response = await fetch(
      `https://api.notexapp.com/v1/create/tasks/${encodeURIComponent(taskId)}/result`,
      {
        headers: {
          'X-API-Key': apiKey,
        },
        signal,
      },
    );

    if (!response.ok) {
      throw new Error(`Failed to poll task: HTTP ${response.status}`);
    }

    const result = (await response.json()) as TaskResultResponse<T>;

    if (result.status === 'SUCCESS') {
      return result.data;
    }

    if (result.status === 'FAILURE' || result.status === 'FAIL') {
      throw new Error(
        result.message ??
          result.error ??
          result.error_key ??
          'Task failed',
      );
    }

    onProgress?.(result);

    await new Promise<void>((resolve, reject) => {
      const timer = setTimeout(resolve, intervalMs);

      signal?.addEventListener(
        'abort',
        () => {
          clearTimeout(timer);
          reject(new DOMException('Task polling was cancelled', 'AbortError'));
        },
        { once: true },
      );
    });
  }

  throw new Error('Task polling timed out');
}

interface CreateNoteResult {
  note_id: string;
  title?: string;
  summary?: string;
}

const result = await pollTask<CreateNoteResult>(
  'task_123456',
  process.env.NOTEX_API_KEY!,
  {
    intervalMs: 4000,
    timeoutMs: 180000,
    onProgress(task) {
      console.log(task.step, task.progress);
    },
  },
);

console.log(result.note_id);

const createResponse = await createContent();

const taskId = createResponse.data.task_id;

const result = await pollTask(taskId, apiKey);