whisperai-sdk 1.0.2 → 2.0.0

package/dist/index.js

@@ -1,3 +1,19 @@
+// src/constant.ts
+var WhisperStatus;
+((WhisperStatus2) => {
+  WhisperStatus2["PENDING"] = "pending";
+  WhisperStatus2["VALIDATING"] = "validating";
+  WhisperStatus2["UPLOADING"] = "uploading";
+  WhisperStatus2["PROCESSING"] = "processing";
+  WhisperStatus2["COMPLETED"] = "completed";
+  WhisperStatus2["FAILED"] = "failed";
+  WhisperStatus2["CANCELLED"] = "cancelled";
+})(WhisperStatus ||= {});
+var DEFAULT_UPLOAD_CHUNK_SIZE = 16 * 1024 * 1024;
+var DEFAULT_MAX_UPLOAD_ATTEMPTS = 5;
+var DEFAULT_POLL_INTERVAL_MS = 2000;
+var DEFAULT_TRANSCRIPTION_TIMEOUT_MS = 30 * 60 * 1000;
+
 // src/errors.ts
 class WhisperError extends Error {
   constructor(message) {
@@ -32,6 +48,38 @@ class WhisperNetworkError extends WhisperError {
   }
 }
 
+class WhisperUploadError extends WhisperError {
+  diagnosticId;
+  code = "UPLOAD_ERROR";
+  constructor(message, diagnosticId, cause) {
+    super(message);
+    this.diagnosticId = diagnosticId;
+    this.cause = cause;
+  }
+}
+
+class WhisperTranscriptionError extends WhisperError {
+  recordingId;
+  status;
+  code = "TRANSCRIPTION_ERROR";
+  constructor(recordingId, status) {
+    super(`Transcription ${recordingId} finished with status ${status}`);
+    this.recordingId = recordingId;
+    this.status = status;
+  }
+}
+
+class WhisperTimeoutError extends WhisperError {
+  recordingId;
+  timeoutMs;
+  code = "TIMEOUT_ERROR";
+  constructor(recordingId, timeoutMs) {
+    super(`Transcription ${recordingId} did not complete within ${timeoutMs}ms`);
+    this.recordingId = recordingId;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
 // src/client.ts
 class WhisperClient {
   cookies;
@@ -39,7 +87,13 @@ class WhisperClient {
   constructor(clientOptions) {
     this.clientOptions = {
       whisperUrl: "https://whisperai.com",
-      chunkSize: 8 * 1024 * 1024,
+      chunkSize: DEFAULT_UPLOAD_CHUNK_SIZE,
+      maxUploadAttempts: DEFAULT_MAX_UPLOAD_ATTEMPTS,
+      initialRetryDelayMs: 1000,
+      maxRetryDelayMs: 30000,
+      diagnostics: true,
+      pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+      transcriptionTimeoutMs: DEFAULT_TRANSCRIPTION_TIMEOUT_MS,
       ...clientOptions
     };
   }
@@ -55,105 +109,319 @@ class WhisperClient {
   subscriptionDetails() {
     return this.recall(() => this.get(this.subscriptionDetailsLink));
   }
-  async upload(file, meta) {
-    if (file instanceof Uint8Array) {
-      const totalChunks2 = this.getCountChunks(file.length);
-      const { recordingId: recordingId2 } = await this.recall(() => this.initChunkRequest(file.length, totalChunks2, meta));
-      await Promise.all(Array.from({ length: totalChunks2 }, (_, i) => this.uploadChunkSlice(file, recordingId2, i)));
-      return this.finalizeChunk(recordingId2);
-    }
-    if (meta.totalSize === undefined) {
+  async startTranscription(file, meta, options = {}) {
+    if (!(file instanceof Uint8Array) && meta.totalSize === undefined) {
       const buffer = new Uint8Array(await new Response(file).arrayBuffer());
-      return this.upload(buffer, { ...meta, totalSize: buffer.length });
+      return this.startTranscription(buffer, { ...meta, totalSize: buffer.length }, options);
+    }
+    const totalSize = file instanceof Uint8Array ? file.byteLength : meta.totalSize;
+    if (totalSize <= 0)
+      throw new WhisperUploadError("Cannot upload an empty audio file");
+    const context = {
+      diagnosticId: options.diagnosticId ?? this.createDiagnosticId(),
+      diagnostics: options.diagnostics ?? this.clientOptions.diagnostics,
+      signal: options.signal,
+      onProgress: options.onProgress
+    };
+    const mimeType = meta.mimeType ?? "application/octet-stream";
+    this.throwIfAborted(context.signal);
+    this.sendDiagnostic(context, {
+      phase: "file-selected",
+      fileName: meta.filename,
+      fileSize: totalSize,
+      fileType: mimeType
+    });
+    this.sendDiagnostic(context, { phase: "init-requested" });
+    let signed;
+    try {
+      signed = await this.recall(() => this.post(this.signUploadLink, this.buildUploadMetadata(meta, totalSize, mimeType), { "X-Diagnostic-Id": context.diagnosticId }, context.signal));
+    } catch (error) {
+      this.sendDiagnostic(context, { phase: "init-failed", errorMessage: this.errorMessage(error) });
+      throw this.withDiagnosticId(error, context.diagnosticId);
+    }
+    let sessionUrl;
+    try {
+      sessionUrl = await this.startResumableSession(signed, context.signal);
+      this.sendDiagnostic(context, { phase: "init-succeeded", recordingId: signed.recordingId });
+    } catch (error) {
+      this.sendDiagnostic(context, {
+        phase: "init-failed",
+        recordingId: signed.recordingId,
+        errorMessage: this.errorMessage(error)
+      });
+      throw new WhisperUploadError("Failed to start resumable upload session", context.diagnosticId, error);
+    }
+    await this.uploadToGcs(file, totalSize, sessionUrl, signed.recordingId, context);
+    this.sendDiagnostic(context, { phase: "chunk-finalize-attempted", recordingId: signed.recordingId });
+    try {
+      const result = await this.recall(() => this.post(this.completeUploadLink(signed.recordingId), {}, { "X-Diagnostic-Id": context.diagnosticId }, context.signal));
+      this.sendDiagnostic(context, { phase: "chunk-finalize-succeeded", recordingId: signed.recordingId });
+      this.sendDiagnostic(context, { phase: "upload-complete", recordingId: signed.recordingId });
+      return result;
+    } catch (error) {
+      this.sendDiagnostic(context, {
+        phase: "chunk-finalize-failed",
+        recordingId: signed.recordingId,
+        errorMessage: this.errorMessage(error)
+      });
+      throw this.withDiagnosticId(error, context.diagnosticId);
     }
-    const totalChunks = this.getCountChunks(meta.totalSize);
-    const { recordingId } = await this.recall(() => this.initChunkRequest(meta.totalSize, totalChunks, meta));
-    await this.uploadFromStream(file, recordingId);
-    return this.finalizeChunk(recordingId);
-  }
-  initChunk(fileBuffer, meta) {
-    const totalChunks = this.getCountChunks(fileBuffer.length);
-    return this.recall(() => this.initChunkRequest(fileBuffer.length, totalChunks, meta));
-  }
-  uploadChunk(chunk, recordingId, chunkIndex) {
-    return this.recall(() => this.uploadChunkRequest(chunk, recordingId, chunkIndex));
-  }
-  finalizeChunk(recordingId) {
-    return this.recall(() => this.post(this.finalizeChunkLink, { recordingId }));
   }
-  transcription(recordingId) {
-    return this.recall(() => this.post(this.transcriptionLink, { recordingId }));
+  async transcribe(file, meta, options = {}) {
+    const started = await this.startTranscription(file, meta, options);
+    return this.waitForTranscription(started.id, options);
+  }
+  requestTranscription(recordingId, signal) {
+    return this.recall(() => this.post(this.transcriptionLink, { recordingId }, {}, signal));
+  }
+  recordingStatus(recordingIds, signal) {
+    if (recordingIds.length === 0)
+      return Promise.resolve([]);
+    const params = new URLSearchParams({ ids: recordingIds.join(",") });
+    return this.recall(() => this.get(`${this.recordingStatusLink}?${params}`, signal));
+  }
+  async waitForTranscription(recordingId, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? this.clientOptions.pollIntervalMs;
+    const timeoutMs = options.timeoutMs ?? this.clientOptions.transcriptionTimeoutMs;
+    const startedAt = Date.now();
+    while (true) {
+      this.throwIfAborted(options.signal);
+      const statuses = await this.recordingStatus([recordingId], options.signal);
+      const status = statuses.find((item) => item.recordingId === recordingId)?.recordingStatus;
+      if (status === "completed" /* COMPLETED */) {
+        const recording = await this.recording(recordingId, options.signal);
+        if (!recording.transcription)
+          throw new WhisperTranscriptionError(recordingId, "completed_without_transcription");
+        return recording;
+      }
+      if (status === "failed" /* FAILED */ || status === "cancelled" /* CANCELLED */ || status === "canceled") {
+        throw new WhisperTranscriptionError(recordingId, status);
+      }
+      if (Date.now() - startedAt >= timeoutMs)
+        throw new WhisperTimeoutError(recordingId, timeoutMs);
+      await this.sleep(Math.min(pollIntervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt))), options.signal);
+    }
   }
   translate(recordingId, language) {
     return this.recall(() => this.post(this.translateLink(recordingId), { targetLanguage: language }));
   }
-  recording(recordingId) {
-    return this.recall(() => this.get(this.recordingLink(recordingId)));
-  }
-  recordings(query) {
-    const params = new URLSearchParams({
-      page: String(query?.page ?? 1),
-      limit: String(query?.limit ?? 5)
-    });
+  recording(recordingId, signal) {
+    return this.recall(() => this.get(this.recordingLink(recordingId), signal));
+  }
+  recordings(query = {}) {
+    const params = new URLSearchParams;
+    params.set("limit", String(query.limit ?? 20));
+    if (query.page !== undefined)
+      params.set("page", String(query.page));
+    if (query.cursor)
+      params.set("cursor", query.cursor);
+    if (query.direction)
+      params.set("direction", query.direction);
+    if (query.search)
+      params.set("q", query.search);
+    if (query.status)
+      params.set("status", query.status);
+    if (query.sort)
+      params.set("sort", query.sort);
     return this.recall(() => this.get(`${this.recordingsLink}?${params}`));
   }
   summary() {
     return this.recall(() => this.get(this.summaryLink));
   }
-  async uploadFromStream(stream, recordingId) {
-    const reader = stream.getReader();
-    let buffer = new Uint8Array(0);
+  buildUploadMetadata(meta, totalSize, mimeType) {
+    const title = meta.title ?? meta.filename.replace(/\.[^.]+$/, "");
+    return {
+      filename: meta.filename,
+      mimeType,
+      totalSize,
+      title,
+      language: meta.language ?? "multi-auto",
+      enableSpeakerDetection: meta.enableSpeakerDetection ?? false,
+      speakerCount: meta.speakerCount ?? "auto",
+      durationSeconds: meta.durationSeconds,
+      transcriptionStyle: meta.transcriptionStyle ?? "clean_readable",
+      importantTerms: meta.importantTerms ?? "",
+      customPrompt: meta.customPrompt ?? "",
+      speakerIdentificationEnabled: meta.speakerIdentificationEnabled ?? false,
+      speakerIdentificationMode: meta.speakerIdentificationMode ?? "role",
+      speakerIdentificationValues: meta.speakerIdentificationValues ?? [],
+      ...meta.folderId === undefined ? {} : { folderId: meta.folderId }
+    };
+  }
+  async startResumableSession(signed, signal) {
+    let response;
+    try {
+      response = await fetch(signed.signedResumableInitUrl, {
+        method: "POST",
+        headers: signed.requiredHeaders,
+        body: "",
+        signal,
+        redirect: "manual"
+      });
+    } catch (cause) {
+      throw new WhisperNetworkError(cause);
+    }
+    if (response.status !== 201)
+      throw new WhisperUploadError(`GCS session initialization failed (${response.status})`);
+    const location = response.headers.get("location");
+    if (!location)
+      throw new WhisperUploadError("GCS session response did not include a Location header");
+    return location;
+  }
+  async uploadToGcs(input, totalSize, sessionUrl, recordingId, context) {
+    let offset = 0;
     let chunkIndex = 0;
+    context.onProgress?.(0);
+    for await (const chunk of this.readChunks(input, this.clientOptions.chunkSize)) {
+      const chunkStart = offset;
+      const expectedEnd = chunkStart + chunk.byteLength;
+      if (expectedEnd > totalSize)
+        throw new WhisperUploadError("Audio stream exceeded declared totalSize", context.diagnosticId);
+      while (offset < expectedEnd) {
+        if (offset < chunkStart) {
+          throw new WhisperUploadError("GCS requested data that is no longer available in the stream", context.diagnosticId);
+        }
+        const slice = chunk.subarray(offset - chunkStart);
+        const result = await this.uploadRangeWithRetry(sessionUrl, slice, offset, totalSize, recordingId, chunkIndex, context);
+        offset = result.nextOffset;
+        context.onProgress?.(Math.min(100, Math.round(offset / totalSize * 100)));
+        if (result.complete)
+          break;
+      }
+      chunkIndex++;
+    }
+    if (offset !== totalSize) {
+      throw new WhisperUploadError(`Audio stream size mismatch: expected ${totalSize}, uploaded ${offset}`, context.diagnosticId);
+    }
+  }
+  async uploadRangeWithRetry(sessionUrl, chunk, offset, totalSize, recordingId, chunkIndex, context) {
+    let currentOffset = offset;
+    let currentChunk = chunk;
+    let lastError;
+    for (let attempt = 1;attempt <= this.clientOptions.maxUploadAttempts; attempt++) {
+      this.throwIfAborted(context.signal);
+      this.sendDiagnostic(context, { phase: "chunk-fetch-sent", recordingId, chunkIndex, attempt });
+      try {
+        const result = await this.putRange(sessionUrl, currentChunk, currentOffset, totalSize, context.signal);
+        this.sendDiagnostic(context, {
+          phase: "chunk-fetch-status",
+          recordingId,
+          chunkIndex,
+          attempt,
+          httpStatus: result.status
+        });
+        return result;
+      } catch (error) {
+        lastError = error;
+        this.sendDiagnostic(context, {
+          phase: "chunk-fetch-error",
+          recordingId,
+          chunkIndex,
+          attempt,
+          errorMessage: this.errorMessage(error)
+        });
+        if (attempt >= this.clientOptions.maxUploadAttempts || !this.isRetryable(error))
+          break;
+        await this.sleep(this.retryDelay(attempt), context.signal);
+        try {
+          const probe = await this.probeUpload(sessionUrl, totalSize, context.signal);
+          if (probe.complete)
+            return probe;
+          if (probe.nextOffset < offset || probe.nextOffset > offset + chunk.byteLength) {
+            throw new WhisperUploadError(`Unexpected GCS resume offset ${probe.nextOffset}`);
+          }
+          if (probe.nextOffset === offset + chunk.byteLength)
+            return probe;
+          currentOffset = probe.nextOffset;
+          currentChunk = chunk.subarray(currentOffset - offset);
+        } catch (probeError) {
+          if (!this.isRetryable(probeError))
+            throw probeError;
+        }
+      }
+    }
+    this.sendDiagnostic(context, {
+      phase: "upload-given-up",
+      recordingId,
+      chunkIndex,
+      errorMessage: this.errorMessage(lastError)
+    });
+    throw new WhisperUploadError("GCS resumable upload failed after all retry attempts", context.diagnosticId, lastError);
+  }
+  async putRange(sessionUrl, chunk, offset, totalSize, signal) {
+    const end = offset + chunk.byteLength;
+    let response;
+    try {
+      response = await fetch(sessionUrl, {
+        method: "PUT",
+        headers: { "Content-Range": `bytes ${offset}-${end - 1}/${totalSize}` },
+        body: this.toArrayBuffer(chunk),
+        signal,
+        redirect: "manual"
+      });
+    } catch (cause) {
+      throw new WhisperNetworkError(cause);
+    }
+    if (response.status === 200 || response.status === 201) {
+      return { complete: true, nextOffset: totalSize, status: response.status };
+    }
+    if (response.status === 308) {
+      return { complete: false, nextOffset: this.nextOffset(response.headers.get("range"), end), status: 308 };
+    }
+    throw new WhisperApiError(response.status, await this.responseData(response));
+  }
+  async probeUpload(sessionUrl, totalSize, signal) {
+    let response;
+    try {
+      response = await fetch(sessionUrl, {
+        method: "PUT",
+        headers: { "Content-Range": `bytes */${totalSize}` },
+        body: "",
+        signal,
+        redirect: "manual"
+      });
+    } catch (cause) {
+      throw new WhisperNetworkError(cause);
+    }
+    if (response.status === 200 || response.status === 201) {
+      return { complete: true, nextOffset: totalSize, status: response.status };
+    }
+    if (response.status === 308) {
+      return { complete: false, nextOffset: this.nextOffset(response.headers.get("range"), 0), status: 308 };
+    }
+    throw new WhisperApiError(response.status, await this.responseData(response));
+  }
+  async* readChunks(input, chunkSize) {
+    if (input instanceof Uint8Array) {
+      for (let offset = 0;offset < input.byteLength; offset += chunkSize) {
+        yield input.subarray(offset, Math.min(offset + chunkSize, input.byteLength));
+      }
+      return;
+    }
+    const reader = input.getReader();
+    let buffer = new Uint8Array(0);
     try {
       while (true) {
         const { done, value } = await reader.read();
-        if (done) {
-          if (buffer.length > 0) {
-            await this.uploadChunk(buffer, recordingId, chunkIndex);
-          }
+        if (done)
           break;
-        }
-        const merged = new Uint8Array(buffer.length + value.length);
+        if (!(value instanceof Uint8Array))
+          throw new TypeError("Audio stream chunks must be Uint8Array values");
+        const merged = new Uint8Array(buffer.byteLength + value.byteLength);
         merged.set(buffer);
-        merged.set(value, buffer.length);
+        merged.set(value, buffer.byteLength);
         buffer = merged;
-        while (buffer.length >= this.clientOptions.chunkSize) {
-          await this.uploadChunk(buffer.subarray(0, this.clientOptions.chunkSize), recordingId, chunkIndex);
-          buffer = buffer.slice(this.clientOptions.chunkSize);
-          chunkIndex++;
+        while (buffer.byteLength >= chunkSize) {
+          yield buffer.slice(0, chunkSize);
+          buffer = buffer.slice(chunkSize);
         }
       }
+      if (buffer.byteLength > 0)
+        yield buffer;
     } finally {
       reader.releaseLock();
     }
   }
-  uploadChunkSlice(fileBuffer, recordingId, chunkIndex) {
-    const start = chunkIndex * this.clientOptions.chunkSize;
-    const end = Math.min(start + this.clientOptions.chunkSize, fileBuffer.length);
-    return this.uploadChunk(fileBuffer.subarray(start, end), recordingId, chunkIndex);
-  }
-  initChunkRequest(totalSize, totalChunks, meta) {
-    return this.post(this.initChunkLink, {
-      filename: meta.filename,
-      durationSeconds: meta.durationSeconds,
-      totalSize,
-      mimeType: meta.mimeType ?? "",
-      title: meta.title ?? meta.filename,
-      enableSpeakerDetection: meta.enableSpeakerDetection ?? false,
-      speakerCount: meta.speakerCount ?? "auto",
-      language: meta.language ?? "",
-      totalChunks
-    });
-  }
-  uploadChunkRequest(chunk, recordingId, chunkIndex) {
-    const buffer = new ArrayBuffer(chunk.byteLength);
-    new Uint8Array(buffer).set(chunk);
-    const formData = new FormData;
-    formData.append("chunk", new Blob([buffer], { type: "application/octet-stream" }), `chunk_${chunkIndex}`);
-    formData.append("recordingId", recordingId.toString());
-    formData.append("chunkIndex", chunkIndex.toString());
-    return this.postForm(this.uploadChunkLink, formData);
-  }
   async recall(call) {
     try {
       if (!this.cookies)
@@ -166,19 +434,17 @@ class WhisperClient {
       return call();
     }
   }
-  get(url) {
-    return this.request(url, { method: "GET" });
+  get(url, signal) {
+    return this.request(url, { method: "GET", signal });
   }
-  post(url, body) {
+  post(url, body, headers = {}, signal) {
     return this.request(url, {
       method: "POST",
       body: JSON.stringify(body),
-      extraHeaders: { "Content-Type": "application/json" }
+      signal,
+      extraHeaders: { "Content-Type": "application/json", ...headers }
     });
   }
-  postForm(url, body) {
-    return this.request(url, { method: "POST", body });
-  }
   async request(url, init) {
     const { extraHeaders, ...fetchInit } = init;
     const cookieHeader = this.cookies?.join("; ");
@@ -201,46 +467,131 @@ class WhisperClient {
     if (!response.ok) {
       if (response.status === 401 || response.status === 403)
         throw new WhisperAuthError;
-      const data = await response.json().catch(() => null);
-      throw new WhisperApiError(response.status, data);
+      throw new WhisperApiError(response.status, await this.responseData(response));
+    }
+    if (response.status === 204)
+      return;
+    return await this.responseData(response);
+  }
+  async responseData(response) {
+    const text = await response.text();
+    if (!text)
+      return;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  sendDiagnostic(context, event) {
+    if (!context.diagnostics)
+      return;
+    const payload = {
+      diagId: context.diagnosticId,
+      ...event,
+      timestamp: new Date().toISOString()
+    };
+    this.request(this.diagnosticsLink, {
+      method: "POST",
+      body: JSON.stringify({ events: [payload] }),
+      extraHeaders: { "Content-Type": "application/json" },
+      signal: context.signal
+    }).catch(() => {
+      return;
+    });
+  }
+  isRetryable(error) {
+    if (error instanceof WhisperNetworkError)
+      return true;
+    return error instanceof WhisperApiError && (error.status === 408 || error.status === 429 || error.status >= 500);
+  }
+  retryDelay(attempt) {
+    const base = Math.min(this.clientOptions.maxRetryDelayMs, this.clientOptions.initialRetryDelayMs * 2 ** (attempt - 1));
+    return base + Math.random() * base * 0.25;
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted)
+        return reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      const onAbort = () => {
+        clearTimeout(timeout);
+        reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+      };
+      const timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  throwIfAborted(signal) {
+    if (signal?.aborted)
+      throw signal.reason ?? new DOMException("Aborted", "AbortError");
+  }
+  nextOffset(range, fallback) {
+    const match = range?.match(/bytes=0-(\d+)/i);
+    return match ? Number(match[1]) + 1 : fallback;
+  }
+  toArrayBuffer(bytes) {
+    const buffer = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(buffer).set(bytes);
+    return buffer;
+  }
+  errorMessage(error) {
+    return error instanceof Error ? error.message : String(error ?? "");
+  }
+  withDiagnosticId(error, diagnosticId) {
+    if (error && typeof error === "object") {
+      try {
+        Object.assign(error, { diagnosticId });
+      } catch {
+        return new WhisperUploadError(this.errorMessage(error), diagnosticId, error);
+      }
+      return error;
     }
-    return response.json();
+    return new WhisperUploadError(this.errorMessage(error), diagnosticId, error);
+  }
+  createDiagnosticId() {
+    return (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`).replace(/-/g, "").slice(0, 8);
   }
   get loginLink() {
-    return `${this.clientOptions.whisperUrl}/api/login`;
+    return `${this.clientOptions.whisperUrl}/api/v2/auth/login`;
   }
   get userLink() {
-    return `${this.clientOptions.whisperUrl}/api/user`;
+    return `${this.clientOptions.whisperUrl}/api/v2/auth/user`;
   }
   get usageLink() {
-    return `${this.clientOptions.whisperUrl}/api/usage`;
+    return `${this.clientOptions.whisperUrl}/api/v2/account/usage`;
   }
   get subscriptionDetailsLink() {
-    return `${this.clientOptions.whisperUrl}/api/subscription-details`;
+    return `${this.clientOptions.whisperUrl}/api/v2/payment/subscription-details`;
   }
-  get initChunkLink() {
-    return `${this.clientOptions.whisperUrl}/api/v2/recordings/chunked/init`;
+  get signUploadLink() {
+    return `${this.clientOptions.whisperUrl}/api/v2/recordings/uploads/sign`;
   }
-  get uploadChunkLink() {
-    return `${this.clientOptions.whisperUrl}/api/v2/recordings/chunked/upload`;
+  completeUploadLink(recordingId) {
+    return `${this.clientOptions.whisperUrl}/api/v2/recordings/uploads/${recordingId}/complete`;
   }
-  get finalizeChunkLink() {
-    return `${this.clientOptions.whisperUrl}/api/v2/recordings/chunked/finalize`;
+  get diagnosticsLink() {
+    return `${this.clientOptions.whisperUrl}/api/v2/diagnostics/upload-breadcrumb`;
   }
   get transcriptionLink() {
     return `${this.clientOptions.whisperUrl}/api/v2/transcription`;
   }
+  get recordingStatusLink() {
+    return `${this.clientOptions.whisperUrl}/api/v2/recordings/status`;
+  }
   get summaryLink() {
-    return `${this.clientOptions.whisperUrl}/api/analytics/summary`;
+    return `${this.clientOptions.whisperUrl}/api/v2/analytics/summary`;
   }
   get recordingsLink() {
-    return `${this.clientOptions.whisperUrl}/api/recordings-paginated`;
+    return `${this.clientOptions.whisperUrl}/api/v2/recordings/paginated`;
   }
   translateLink(recordingId) {
     return `${this.clientOptions.whisperUrl}/api/v2/translation/${recordingId}/translate`;
   }
   recordingLink(recordingId) {
-    return `${this.clientOptions.whisperUrl}/api/recordings/${recordingId}`;
+    return `${this.clientOptions.whisperUrl}/api/v2/recordings/${recordingId}`;
   }
   mergeCookies(incoming) {
     const map = new Map;
@@ -253,22 +604,19 @@ class WhisperClient {
     }
     this.cookies = [...map.values()];
   }
-  getCountChunks(size) {
-    return Math.ceil(size / this.clientOptions.chunkSize);
-  }
 }
-// src/constant.ts
-var WhisperStatus;
-((WhisperStatus2) => {
-  WhisperStatus2["PENDING"] = "pending";
-  WhisperStatus2["VALIDATING"] = "validating";
-  WhisperStatus2["UPLOADING"] = "uploading";
-  WhisperStatus2["PROCESSING"] = "processing";
-  WhisperStatus2["COMPLETED"] = "completed";
-  WhisperStatus2["FAILED"] = "failed";
-  WhisperStatus2["CANCELLED"] = "cancelled";
-})(WhisperStatus ||= {});
 export {
+  WhisperUploadError,
+  WhisperTranscriptionError,
+  WhisperTimeoutError,
   WhisperStatus,
-  WhisperClient
+  WhisperNetworkError,
+  WhisperError,
+  WhisperClient,
+  WhisperAuthError,
+  WhisperApiError,
+  DEFAULT_UPLOAD_CHUNK_SIZE,
+  DEFAULT_TRANSCRIPTION_TIMEOUT_MS,
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_MAX_UPLOAD_ATTEMPTS
 };