@mulingai-npm/redis 3.29.1 → 3.29.3

package/dist/loggers/mulingstream-chunk-logger.d.ts

@@ -6,9 +6,7 @@ export interface ChunkLogOptions {
     language?: boolean;
     processLength?: boolean;
     finalTranscription?: boolean;
-    sttStatus?: boolean;
-    audioFilePath?: boolean;
-    stt?: boolean;
+    streamingChunk?: boolean;
     translation?: boolean;
     tts?: boolean;
     label?: string;

package/dist/loggers/mulingstream-chunk-logger.js

@@ -5,13 +5,11 @@ const mulingstream_chunk_manager_1 = require("../managers/mulingstream-chunk-man
 const defaults = {
     chunkId: false,
     chunkNumber: true,
-    audioFilePath: true,
     roomId: false,
     processLength: false,
     language: false,
     finalTranscription: true,
-    sttStatus: true,
-    stt: false,
+    streamingChunk: false,
     translation: false,
     tts: true,
     label: ''
@@ -62,18 +60,14 @@ class MulingstreamChunkLogger extends mulingstream_chunk_manager_1.MulingstreamC
             out.roomId = chunk.roomId;
         if (o.chunkNumber)
             out.chunkNumber = chunk.chunkNumber;
-        if (o.audioFilePath)
-            out.audioFilePath = chunk.audioChunk.audioFilePath;
+        if (o.streamingChunk)
+            out.streamingChunk = chunk.streamingChunk;
         if (o.processLength)
             out.processLength = Date.now() - chunk.createdAt + 'ms';
         if (o.language)
             out.language = chunk.language;
         if (o.finalTranscription)
             out.finalTranscription = chunk.finalTranscription;
-        if (o.sttStatus)
-            out.sttStatus = chunk.sttStatus;
-        if (o.stt)
-            out.stt = chunk.stt;
         if (o.translation)
             out.translation = chunk.translation;
         if (o.tts)

package/dist/managers/mulingstream-chunk-manager.d.ts

@@ -1,36 +1,30 @@
 import { RedisClient } from '../redis-client';
 export type StepStatus = 'INIT' | 'DISCARDED' | 'READY' | 'USED';
-export type SttService = 'azure' | 'whisper' | 'deepgram';
+export type SttService = 'azure' | 'deepgram';
 export type SttProvider = {
     service: SttService;
     model?: string;
 };
+export type StreamingChunkData = {
+    startMs: number;
+    endMs: number;
+    durationMs: number;
+    confidence: number;
+    wordCount: number;
+    speechFinal: boolean;
+    provider: string;
+    model?: string;
+};
 export type MulingstreamChunkData = {
     chunkId: string;
     roomId: string;
     chunkNumber: number;
     language: string;
-    sttProviders: SttProvider[];
     targetLanguages: string[];
     shortCodeTargetLanguages: string[];
     finalTranscription: string;
-    sttStatus: StepStatus;
     createdAt: number;
-    audioChunk: {
-        start: number;
-        end: number;
-        duration: number;
-        isFirst: boolean;
-        isLast: boolean;
-        audioFilePath: string;
-    };
-    stt: {
-        [service: string]: {
-            transcription: string;
-            model?: string;
-            status: StepStatus;
-        };
-    };
+    streamingChunk: StreamingChunkData;
     translation: {
         [language: string]: {
             translation: string;
@@ -45,6 +39,8 @@ export type MulingstreamChunkData = {
             duration?: number;
         };
     };
+    isComplete: boolean;
+    isSaved: boolean;
 };
 export declare class MulingstreamChunkManager {
     private redisClient;
@@ -60,39 +56,31 @@ export declare class MulingstreamChunkManager {
     getRooms(): Promise<string[]>;
     getMulingstreamChunksByRoom(roomId: string): Promise<MulingstreamChunkData[] | null>;
     getRoomById(roomId: string): Promise<MulingstreamChunkData[]>;
-    addMulingstreamChunk(params: {
+    /**
+     * Add a streaming chunk with STT already completed
+     * This is the primary method for streaming-based transcription
+     */
+    addStreamingChunk(params: {
         roomId: string;
         chunkNumber: number;
         language: string;
-        start: number;
-        end: number;
-        duration: number;
-        isFirst: boolean;
-        isLast: boolean;
-        sttProviders: SttProvider[];
+        transcription: string;
+        sttProvider: SttProvider;
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
+        streamingData: {
+            startMs: number;
+            endMs: number;
+            durationMs: number;
+            confidence: number;
+            wordCount: number;
+            speechFinal: boolean;
+        };
     }): Promise<MulingstreamChunkData>;
     private getChunkId;
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
     private withChunk;
-    updateAudioFilePath(roomId: string, chunkNumber: number, audioFilePath: string): Promise<MulingstreamChunkData | null>;
-    updateStt(roomId: string, n: number, service: SttService, opt: {
-        transcription?: string;
-        sttStatus?: StepStatus;
-    }): Promise<MulingstreamChunkData | null>;
-    updateSttObject(roomId: string, n: number, newStt: Record<string, {
-        transcription: string;
-        model?: string;
-        status: StepStatus;
-    }>): Promise<MulingstreamChunkData | null>;
-    discardStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
-    updateSttAsUsed(roomId: string, chunkNumber: number): Promise<MulingstreamChunkData | null>;
-    updateFinalTranscription(roomId: string, n: number, opt: {
-        transcription?: string;
-        sttStatus?: StepStatus;
-    }): Promise<MulingstreamChunkData | null>;
-    discardPostStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    updateFinalTranscription(roomId: string, n: number, transcription: string): Promise<MulingstreamChunkData | null>;
     discardLanguage(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData | null>;
     discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];
@@ -110,6 +98,26 @@ export declare class MulingstreamChunkManager {
         duration?: number;
     }): Promise<MulingstreamChunkData | null>;
     areTranslationsProcessed(roomId: string, n: number): Promise<boolean>;
+    /**
+     * Check if all TTS for all target languages are done (READY, USED, or DISCARDED - not INIT)
+     */
+    isChunkComplete(roomId: string, n: number): Promise<boolean>;
+    /**
+     * Mark a chunk as complete (all TTS finished for all target languages)
+     */
+    markChunkComplete(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    /**
+     * Mark a chunk as saved to database
+     */
+    markChunkSaved(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    /**
+     * Get all complete but unsaved chunks for a room
+     */
+    getCompleteUnsavedChunks(roomId: string): Promise<MulingstreamChunkData[]>;
+    /**
+     * Mark multiple chunks as saved in batch
+     */
+    markChunksSaved(roomId: string, chunkNumbers: number[]): Promise<void>;
     /**
      * @deprecated This function is replaced by ChunkSequencer (5-sequencer-handler.ts)
      *

package/dist/managers/mulingstream-chunk-manager.js

@@ -29,19 +29,18 @@ class MulingstreamChunkManager {
             roomId: h.roomId,
             chunkNumber: parseInt(h.chunkNumber, 10),
             language: h.language,
-            sttProviders: this.deserialize(h.sttProviders),
             targetLanguages: this.deserialize(h.targetLanguages),
             shortCodeTargetLanguages: this.deserialize(h.shortCodeTargetLanguages),
             finalTranscription: h.finalTranscription,
-            sttStatus: h.sttStatus,
             createdAt: parseInt(h.createdAt, 10),
-            audioChunk: this.deserialize(h.audioChunk),
-            stt: this.deserialize(h.stt),
+            streamingChunk: this.deserialize(h.streamingChunk),
             translation: this.deserialize(h.translation),
-            tts: this.deserialize(h.tts)
+            tts: this.deserialize(h.tts),
+            isComplete: h.isComplete === 'true',
+            isSaved: h.isSaved === 'true'
         };
     }
-    getTimeout(start, end) {
+    getTimeout() {
         return 25000;
     }
     async initRoom(roomId) {
@@ -69,9 +68,14 @@ class MulingstreamChunkManager {
     getRoomById(roomId) {
         return this.getMulingstreamChunksByRoom(roomId);
     }
-    async addMulingstreamChunk(params) {
+    /**
+     * Add a streaming chunk with STT already completed
+     * This is the primary method for streaming-based transcription
+     */
+    async addStreamingChunk(params) {
         var _a, _b;
-        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
+        const { roomId, chunkNumber, language, transcription, sttProvider, targetLanguages, shortCodeTargetLanguages, streamingData } = params;
+        // Clear room if this is first chunk (new session)
         if (chunkNumber === 1) {
             const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
             if (old.length) {
@@ -82,6 +86,7 @@ class MulingstreamChunkManager {
             }
         }
         else {
+            // Remove duplicate chunk numbers
             const dup = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), chunkNumber, chunkNumber);
             if (dup.length) {
                 const p = this.redisClient.pipeline();
@@ -91,13 +96,20 @@ class MulingstreamChunkManager {
             }
         }
         const chunkId = this.generateChunkId(roomId, chunkNumber);
-        const audioChunk = { start, end, duration, isFirst, isLast, audioFilePath: '' };
-        const stt = {};
-        sttProviders.forEach((p) => (stt[p.service] = { transcription: '', model: p.model, status: 'INIT' }));
+        // Streaming chunk data (includes STT provider info)
+        const streamingChunk = {
+            startMs: streamingData.startMs,
+            endMs: streamingData.endMs,
+            durationMs: streamingData.durationMs,
+            confidence: streamingData.confidence,
+            wordCount: streamingData.wordCount,
+            speechFinal: streamingData.speechFinal,
+            provider: sttProvider.service,
+            model: sttProvider.model
+        };
         const translation = {};
         const tts = {};
-        // Use ISO codes (targetLanguages) for translation/tts keys, NOT short codes
-        // This ensures consistency throughout the pipeline - we can always derive short codes from ISO codes when needed
+        // Use ISO codes (targetLanguages) for translation/tts keys
         targetLanguages.forEach((l) => {
             translation[l] = { translation: '', status: 'INIT' };
             tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false };
@@ -108,32 +120,30 @@ class MulingstreamChunkManager {
             roomId,
             chunkNumber,
             language,
-            sttProviders,
             targetLanguages,
             shortCodeTargetLanguages,
-            finalTranscription: '',
-            sttStatus: 'INIT',
+            finalTranscription: transcription,
             createdAt,
-            audioChunk,
-            stt,
+            streamingChunk,
             translation,
-            tts
+            tts,
+            isComplete: false,
+            isSaved: false
         };
         const hash = {
             chunkId,
             roomId,
             chunkNumber: String(chunkNumber),
             language,
-            sttProviders: this.serialize(sttProviders),
             targetLanguages: this.serialize(targetLanguages),
             shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
-            finalTranscription: '',
-            sttStatus: 'INIT',
+            finalTranscription: transcription,
             createdAt: String(createdAt),
-            audioChunk: this.serialize(audioChunk),
-            stt: this.serialize(stt),
+            streamingChunk: this.serialize(streamingChunk),
             translation: this.serialize(translation),
-            tts: this.serialize(tts)
+            tts: this.serialize(tts),
+            isComplete: 'false',
+            isSaved: 'false'
         };
         const pipe = this.redisClient.pipeline();
         pipe.hset(this.chunkHashKey(chunkId), hash);
@@ -143,6 +153,7 @@ class MulingstreamChunkManager {
         pipe.zrange(this.roomZsetKey(roomId), 0, -ROOM_ARRAY_LENGTH - 1, 'WITHSCORES');
         const execResults = await pipe.exec();
         const oldPairs = ((_b = (_a = execResults === null || execResults === void 0 ? void 0 : execResults[4]) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : []);
+        // Trim old chunks if room exceeds max length
         if (Array.isArray(oldPairs) && oldPairs.length) {
             const oldIds = [];
             for (let i = 0; i < oldPairs.length; i += 2)
@@ -178,65 +189,19 @@ class MulingstreamChunkManager {
         const p = this.redisClient.pipeline();
         p.hset(key, {
             finalTranscription: chunk.finalTranscription,
-            sttStatus: chunk.sttStatus,
-            stt: this.serialize(chunk.stt),
             translation: this.serialize(chunk.translation),
             tts: this.serialize(chunk.tts),
-            audioChunk: this.serialize(chunk.audioChunk)
+            streamingChunk: this.serialize(chunk.streamingChunk),
+            isComplete: String(chunk.isComplete),
+            isSaved: String(chunk.isSaved)
         });
         p.expire(key, EXPIRATION);
         await p.exec();
         return chunk;
     }
-    async updateAudioFilePath(roomId, chunkNumber, audioFilePath) {
-        return this.withChunk(roomId, chunkNumber, (chunk) => {
-            chunk.audioChunk.audioFilePath = audioFilePath;
-        });
-    }
-    async updateStt(roomId, n, service, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            if (!c.stt[service])
-                return;
-            if (opt.transcription !== undefined)
-                c.stt[service].transcription = opt.transcription;
-            if (opt.sttStatus !== undefined)
-                c.stt[service].status = opt.sttStatus;
-        });
-    }
-    async updateSttObject(roomId, n, newStt) {
+    async updateFinalTranscription(roomId, n, transcription) {
         return this.withChunk(roomId, n, (c) => {
-            c.stt = newStt;
-        });
-    }
-    async discardStt(roomId, n) {
-        return this.withChunk(roomId, n, (c) => {
-            Object.keys(c.stt).forEach((p) => {
-                c.stt[p].transcription = '';
-                c.stt[p].status = 'DISCARDED';
-            });
-            c.finalTranscription = '';
-            c.sttStatus = 'DISCARDED';
-        });
-    }
-    async updateSttAsUsed(roomId, chunkNumber) {
-        return this.withChunk(roomId, chunkNumber, (chunk) => {
-            Object.keys(chunk.stt).forEach((sttProvider) => {
-                chunk.stt[sttProvider].status = 'USED';
-            });
-        });
-    }
-    async updateFinalTranscription(roomId, n, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            if (opt.transcription !== undefined)
-                c.finalTranscription = opt.transcription;
-            if (opt.sttStatus !== undefined)
-                c.sttStatus = opt.sttStatus;
-        });
-    }
-    async discardPostStt(roomId, n) {
-        return this.withChunk(roomId, n, (c) => {
-            Object.values(c.translation).forEach((t) => (t.status = 'DISCARDED'));
-            Object.values(c.tts).forEach((t) => (t.status = 'DISCARDED'));
+            c.finalTranscription = transcription;
         });
     }
     async discardLanguage(roomId, n, lang) {
@@ -302,6 +267,47 @@ class MulingstreamChunkManager {
         const c = await this.getMulingstreamChunkById(roomId, n);
         return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');
     }
+    /**
+     * Check if all TTS for all target languages are done (READY, USED, or DISCARDED - not INIT)
+     */
+    async isChunkComplete(roomId, n) {
+        const c = await this.getMulingstreamChunkById(roomId, n);
+        if (!c)
+            return false;
+        return Object.values(c.tts).every((t) => t.status !== 'INIT');
+    }
+    /**
+     * Mark a chunk as complete (all TTS finished for all target languages)
+     */
+    async markChunkComplete(roomId, n) {
+        return this.withChunk(roomId, n, (c) => {
+            c.isComplete = true;
+        });
+    }
+    /**
+     * Mark a chunk as saved to database
+     */
+    async markChunkSaved(roomId, n) {
+        return this.withChunk(roomId, n, (c) => {
+            c.isSaved = true;
+        });
+    }
+    /**
+     * Get all complete but unsaved chunks for a room
+     */
+    async getCompleteUnsavedChunks(roomId) {
+        var _a;
+        const chunks = (_a = (await this.getMulingstreamChunksByRoom(roomId))) !== null && _a !== void 0 ? _a : [];
+        return chunks.filter((c) => c.isComplete && !c.isSaved);
+    }
+    /**
+     * Mark multiple chunks as saved in batch
+     */
+    async markChunksSaved(roomId, chunkNumbers) {
+        for (const n of chunkNumbers) {
+            await this.markChunkSaved(roomId, n);
+        }
+    }
     /**
      * @deprecated This function is replaced by ChunkSequencer (5-sequencer-handler.ts)
      *
@@ -348,9 +354,8 @@ class MulingstreamChunkManager {
         const now = Date.now();
         for (let i = lastDone + 1; i < window.length; i++) {
             const entry = window[i].tts[lang];
-            const audio = window[i].audioChunk;
             if (entry.status === 'INIT') {
-                if (now - window[i].createdAt > this.getTimeout(audio.start, audio.end))
+                if (now - window[i].createdAt > this.getTimeout())
                     entry.status = 'DISCARDED';
                 else
                     blocked = true;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mulingai-npm/redis",
-    "version": "3.29.1",
+    "version": "3.29.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {