whisperai-sdk 1.0.0 → 1.0.2

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ClientOptions, UserInfo, UsageInfo, InitMetaFile, InitChunkResponse, UploadChunkResponse, FinalizeChunkResponse, TranscriptionResponse, TranslateResponse, SummaryResponse, RecordingResponse, RecordingsQuery, RecordingsResponse, SubscriptionDetailsResponse } from "./types.js";
+import type { ClientOptions, FinalizeChunkResponse, InitChunkResponse, InitMetaFile, RecordingResponse, RecordingsQuery, RecordingsResponse, SummaryResponse, SubscriptionDetailsResponse, TranscriptionResponse, TranslateResponse, UploadChunkResponse, UsageInfo, UserInfo } from "./types.js";
 export declare class WhisperClient {
     private cookies?;
     private readonly clientOptions;
@@ -7,15 +7,24 @@ export declare class WhisperClient {
     user(): Promise<UserInfo>;
     usage(): Promise<UsageInfo>;
     subscriptionDetails(): Promise<SubscriptionDetailsResponse>;
-    upload(fileBuffer: Uint8Array, meta: InitMetaFile): Promise<FinalizeChunkResponse>;
+    upload(file: Uint8Array | ReadableStream<Uint8Array>, meta: InitMetaFile): Promise<FinalizeChunkResponse>;
     initChunk(fileBuffer: Uint8Array, meta: InitMetaFile): Promise<InitChunkResponse>;
-    uploadChunk(fileBuffer: Uint8Array, recordingId: number, chunkIndex: number): Promise<UploadChunkResponse>;
+    uploadChunk(chunk: Uint8Array, recordingId: number, chunkIndex: number): Promise<UploadChunkResponse>;
     finalizeChunk(recordingId: number): Promise<FinalizeChunkResponse>;
     transcription(recordingId: number): Promise<TranscriptionResponse>;
     translate(recordingId: number, language: string): Promise<TranslateResponse>;
     recording(recordingId: number): Promise<RecordingResponse>;
     recordings(query?: RecordingsQuery): Promise<RecordingsResponse>;
     summary(): Promise<SummaryResponse>;
+    private uploadFromStream;
+    private uploadChunkSlice;
+    private initChunkRequest;
+    private uploadChunkRequest;
+    private recall;
+    private get;
+    private post;
+    private postForm;
+    private request;
     private get loginLink();
     private get userLink();
     private get usageLink();
@@ -25,11 +34,9 @@ export declare class WhisperClient {
     private get finalizeChunkLink();
     private get transcriptionLink();
     private get summaryLink();
+    private get recordingsLink();
     private translateLink;
     private recordingLink;
-    private get recordingsLink();
+    private mergeCookies;
     private getCountChunks;
-    private get requestOptions();
-    private recall;
-    private handleRequest;
 }

package/dist/index.js

@@ -1,6 +1,3 @@
-// src/client.ts
-import axios from "axios";
-
 // src/errors.ts
 class WhisperError extends Error {
   constructor(message) {
@@ -47,65 +44,167 @@ class WhisperClient {
     };
   }
   login() {
-    return this.handleRequest(axios.post(this.loginLink, this.clientOptions.login));
+    return this.post(this.loginLink, this.clientOptions.login);
   }
   user() {
-    return this.recall(() => axios.get(this.userLink, this.requestOptions));
+    return this.recall(() => this.get(this.userLink));
   }
   usage() {
-    return this.recall(() => axios.get(this.usageLink, this.requestOptions));
+    return this.recall(() => this.get(this.usageLink));
   }
   subscriptionDetails() {
-    return this.recall(() => axios.get(this.subscriptionDetailsLink, this.requestOptions));
+    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) {
+      const buffer = new Uint8Array(await new Response(file).arrayBuffer());
+      return this.upload(buffer, { ...meta, totalSize: buffer.length });
+    }
+    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);
   }
-  upload(fileBuffer, meta) {
+  initChunk(fileBuffer, meta) {
     const totalChunks = this.getCountChunks(fileBuffer.length);
-    return this.initChunk(fileBuffer, meta).then((response) => Promise.all(Array.from({ length: totalChunks }, (_, i) => this.uploadChunk(fileBuffer, response.recordingId, i))).then(() => this.finalizeChunk(response.recordingId)));
+    return this.recall(() => this.initChunkRequest(fileBuffer.length, totalChunks, meta));
   }
-  initChunk(fileBuffer, meta) {
-    return this.recall(() => axios.post(this.initChunkLink, {
+  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 }));
+  }
+  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)
+    });
+    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);
+    let chunkIndex = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (buffer.length > 0) {
+            await this.uploadChunk(buffer, recordingId, chunkIndex);
+          }
+          break;
+        }
+        const merged = new Uint8Array(buffer.length + value.length);
+        merged.set(buffer);
+        merged.set(value, buffer.length);
+        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++;
+        }
+      }
+    } 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: fileBuffer.length,
+      totalSize,
       mimeType: meta.mimeType ?? "",
       title: meta.title ?? meta.filename,
       enableSpeakerDetection: meta.enableSpeakerDetection ?? false,
       speakerCount: meta.speakerCount ?? "auto",
       language: meta.language ?? "",
-      totalChunks: this.getCountChunks(fileBuffer.length)
-    }, this.requestOptions));
+      totalChunks
+    });
   }
-  uploadChunk(fileBuffer, recordingId, chunkIndex) {
-    const start = chunkIndex * this.clientOptions.chunkSize;
-    const end = Math.min(start + this.clientOptions.chunkSize, fileBuffer.length);
-    const chunk = fileBuffer.slice(start, end);
-    const blob = new Blob([chunk], { type: "application/octet-stream" });
+  uploadChunkRequest(chunk, recordingId, chunkIndex) {
+    const buffer = new ArrayBuffer(chunk.byteLength);
+    new Uint8Array(buffer).set(chunk);
     const formData = new FormData;
-    formData.append("chunk", blob, `chunk_${chunkIndex}`);
+    formData.append("chunk", new Blob([buffer], { type: "application/octet-stream" }), `chunk_${chunkIndex}`);
     formData.append("recordingId", recordingId.toString());
     formData.append("chunkIndex", chunkIndex.toString());
-    return this.recall(() => axios.post(this.uploadChunkLink, formData, this.requestOptions));
-  }
-  finalizeChunk(recordingId) {
-    return this.recall(() => axios.post(this.finalizeChunkLink, { recordingId }, this.requestOptions));
+    return this.postForm(this.uploadChunkLink, formData);
   }
-  transcription(recordingId) {
-    return this.recall(() => axios.post(this.transcriptionLink, { recordingId }, this.requestOptions));
+  async recall(call) {
+    try {
+      if (!this.cookies)
+        await this.login();
+      return await call();
+    } catch (error) {
+      if (!(error instanceof WhisperAuthError))
+        throw error;
+      await this.login();
+      return call();
+    }
   }
-  translate(recordingId, language) {
-    return this.recall(() => axios.post(this.translateLink(recordingId), { targetLanguage: language }, this.requestOptions));
+  get(url) {
+    return this.request(url, { method: "GET" });
   }
-  recording(recordingId) {
-    return this.recall(() => axios.get(this.recordingLink(recordingId), this.requestOptions));
+  post(url, body) {
+    return this.request(url, {
+      method: "POST",
+      body: JSON.stringify(body),
+      extraHeaders: { "Content-Type": "application/json" }
+    });
   }
-  recordings(query) {
-    return this.recall(() => axios.get(this.recordingsLink, {
-      ...this.requestOptions,
-      params: { page: 1, limit: 5, ...query ?? {} }
-    }));
+  postForm(url, body) {
+    return this.request(url, { method: "POST", body });
   }
-  summary() {
-    return this.recall(() => axios.get(this.summaryLink, this.requestOptions));
+  async request(url, init) {
+    const { extraHeaders, ...fetchInit } = init;
+    const cookieHeader = this.cookies?.join("; ");
+    let response;
+    try {
+      response = await fetch(url, {
+        ...fetchInit,
+        headers: {
+          "cache-control": "no-cache",
+          ...cookieHeader ? { Cookie: cookieHeader } : {},
+          ...extraHeaders
+        }
+      });
+    } catch (cause) {
+      throw new WhisperNetworkError(cause);
+    }
+    const setCookies = response.headers.getSetCookie?.() ?? [];
+    if (setCookies.length > 0)
+      this.mergeCookies(setCookies);
+    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);
+    }
+    return response.json();
   }
   get loginLink() {
     return `${this.clientOptions.whisperUrl}/api/login`;
@@ -134,57 +233,29 @@ class WhisperClient {
   get summaryLink() {
     return `${this.clientOptions.whisperUrl}/api/analytics/summary`;
   }
+  get recordingsLink() {
+    return `${this.clientOptions.whisperUrl}/api/recordings-paginated`;
+  }
   translateLink(recordingId) {
     return `${this.clientOptions.whisperUrl}/api/v2/translation/${recordingId}/translate`;
   }
   recordingLink(recordingId) {
     return `${this.clientOptions.whisperUrl}/api/recordings/${recordingId}`;
   }
-  get recordingsLink() {
-    return `${this.clientOptions.whisperUrl}/api/recordings-paginated`;
+  mergeCookies(incoming) {
+    const map = new Map;
+    for (const cookie of [...this.cookies ?? [], ...incoming]) {
+      const pair = cookie.split(";")[0]?.trim();
+      if (!pair)
+        continue;
+      const name = pair.split("=")[0].trim();
+      map.set(name, pair);
+    }
+    this.cookies = [...map.values()];
   }
   getCountChunks(size) {
     return Math.ceil(size / this.clientOptions.chunkSize);
   }
-  get requestOptions() {
-    return {
-      headers: {
-        Cookie: this.cookies
-      }
-    };
-  }
-  async recall(call) {
-    try {
-      if (typeof this.cookies !== "string")
-        await this.login();
-      return await this.handleRequest(call());
-    } catch (error) {
-      if (error.code !== "AUTH_ERROR") {
-        throw error;
-      }
-      await this.login();
-      return this.handleRequest(call());
-    }
-  }
-  async handleRequest(request) {
-    try {
-      const response = await request;
-      this.cookies = (response.headers["set-cookie"] ?? []).join("; ");
-      return response.data;
-    } catch (err) {
-      console.log("err", err);
-      if (axios.isAxiosError(err)) {
-        if (!err.response) {
-          throw new WhisperNetworkError(err);
-        }
-        if (err.response.status === 401) {
-          throw new WhisperAuthError;
-        }
-        throw new WhisperApiError(err.response.status, err.response.data);
-      }
-      throw err;
-    }
-  }
 }
 // src/constant.ts
 var WhisperStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whisperai-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "TypeScript SDK for WhisperAI: methods and interfaces for interacting with the service without external runtime dependencies.",
   "keywords": [
     "whisper",
@@ -32,37 +32,33 @@
     "dist"
   ],
   "scripts": {
-    "build": "npm run clean && bun build ./src/index.ts --outdir ./dist --target=node --format=esm --external axios && tsc --emitDeclarationOnly",
+    "build": "npm run clean && bun build ./src/index.ts --outdir ./dist --target=node --format=esm && tsc --emitDeclarationOnly",
     "format": "prettier --write \"src/**/*.ts\"",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
     "clean": "rm -rf dist",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release": "semantic-release"
   },
-  "dependencies": {
-    "axios": "^1.13.2"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "@commitlint/cli": "20.2.0",
-    "@commitlint/config-conventional": "20.2.0",
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
     "@eslint/js": "9.39.2",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/exec": "7.1.0",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/github": "12.0.2",
-    "@semantic-release/npm": "13.1.3",
-    "@types/bun": "^1.3.5",
-    "@types/node": "25.0.3",
-    "@typescript-eslint/eslint-plugin": "8.50.1",
-    "@typescript-eslint/parser": "8.50.1",
-    "conventional-changelog-conventionalcommits": "9.1.0",
+    "@semantic-release/github": "12.0.6",
+    "@semantic-release/npm": "13.1.5",
+    "@types/bun": "^1.3.11",
+    "@types/node": "25.5.2",
+    "conventional-changelog-conventionalcommits": "9.3.1",
     "eslint": "9.39.2",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-prettier": "5.5.4",
-    "prettier": "3.7.4",
-    "semantic-release": "25.0.2",
+    "eslint-plugin-prettier": "5.5.5",
+    "prettier": "3.8.1",
+    "semantic-release": "25.0.3",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.50.1"
+    "typescript-eslint": "8.58.0"
   },
   "engines": {
     "node": ">=22.0.0"