@mulingai-npm/redis 3.38.1 → 3.38.3

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

@@ -20,6 +20,16 @@ export type StreamingChunkData = {
     model?: string;
     words?: TranscriptionWord[];
 };
+export type SttHistoryEntry = {
+    chunkNumber: number;
+    source: 'stt' | 'llm';
+    provider: string;
+};
+export type TranslationHint = {
+    type: string;
+    ref: string;
+    text: string;
+};
 export type MulingstreamChunkData = {
     chunkId: string;
     roomId: string;
@@ -29,6 +39,7 @@ export type MulingstreamChunkData = {
     targetLanguages: string[];
     shortCodeTargetLanguages: string[];
     finalTranscription: string;
+    sanitizedTranscription?: string;
     createdAt: number;
     creditUsageSessionId?: number | null;
     streamingChunk: StreamingChunkData;
@@ -36,6 +47,7 @@ export type MulingstreamChunkData = {
         [language: string]: {
             translation: string;
             status: StepStatus;
+            hints?: TranslationHint[];
         };
     };
     tts: {
@@ -48,6 +60,11 @@ export type MulingstreamChunkData = {
     };
     isComplete: boolean;
     isSaved: boolean;
+    llmTranscription?: string;
+    llmWords?: TranscriptionWord[];
+    transcriptionSource: 'stt' | 'llm';
+    routeUsed?: 'LLM' | 'AZURE' | 'AZURE_FALLBACK';
+    sttHistory?: SttHistoryEntry[];
 };
 export declare class MulingstreamChunkManager {
     private redisClient;
@@ -91,6 +108,21 @@ export declare class MulingstreamChunkManager {
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
     private withChunk;
     updateFinalTranscription(roomId: string, n: number, transcription: string): Promise<MulingstreamChunkData | null>;
+    /**
+     * Update chunk with LLM-sanitized transcription from SmartTranslate.
+     * If the sanitized text differs from the original, sets transcriptionSource to 'llm'
+     * and updates finalTranscription to the sanitized version.
+     * Returns the chunk (caller can compare original vs sanitized to decide on TRANSCRIPTION_CORRECTED).
+     */
+    updateLlmTranscription(roomId: string, n: number, opts: {
+        llmTranscription: string;
+        llmWords?: TranscriptionWord[];
+        routeUsed: 'LLM' | 'AZURE' | 'AZURE_FALLBACK';
+        sttHistoryEntry?: SttHistoryEntry;
+    }): Promise<{
+        chunk: MulingstreamChunkData | null;
+        wasChanged: boolean;
+    }>;
     discardLanguage(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData | null>;
     discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];

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

@@ -39,7 +39,13 @@ class MulingstreamChunkManager {
             translation: this.deserialize(h.translation),
             tts: this.deserialize(h.tts),
             isComplete: h.isComplete === 'true',
-            isSaved: h.isSaved === 'true'
+            isSaved: h.isSaved === 'true',
+            // SmartTranslate fields
+            llmTranscription: h.llmTranscription || undefined,
+            llmWords: h.llmWords ? this.deserialize(h.llmWords) : undefined,
+            transcriptionSource: h.transcriptionSource || 'stt',
+            routeUsed: h.routeUsed || undefined,
+            sttHistory: h.sttHistory ? this.deserialize(h.sttHistory) : undefined
         };
     }
     getTimeout() {
@@ -133,7 +139,9 @@ class MulingstreamChunkManager {
             translation,
             tts,
             isComplete: false,
-            isSaved: false
+            isSaved: false,
+            // SmartTranslate defaults
+            transcriptionSource: 'stt'
         };
         const hash = {
             chunkId,
@@ -150,7 +158,8 @@ class MulingstreamChunkManager {
             translation: this.serialize(translation),
             tts: this.serialize(tts),
             isComplete: 'false',
-            isSaved: 'false'
+            isSaved: 'false',
+            transcriptionSource: 'stt'
         };
         const pipe = this.redisClient.pipeline();
         pipe.hset(this.chunkHashKey(chunkId), hash);
@@ -194,14 +203,25 @@ class MulingstreamChunkManager {
         const chunk = this.hashToChunk(raw);
         await fn(chunk);
         const p = this.redisClient.pipeline();
-        p.hset(key, {
+        const updateHash = {
             finalTranscription: chunk.finalTranscription,
             translation: this.serialize(chunk.translation),
             tts: this.serialize(chunk.tts),
             streamingChunk: this.serialize(chunk.streamingChunk),
             isComplete: String(chunk.isComplete),
-            isSaved: String(chunk.isSaved)
-        });
+            isSaved: String(chunk.isSaved),
+            transcriptionSource: chunk.transcriptionSource || 'stt'
+        };
+        // SmartTranslate fields (only set if populated)
+        if (chunk.llmTranscription !== undefined)
+            updateHash.llmTranscription = chunk.llmTranscription;
+        if (chunk.llmWords !== undefined)
+            updateHash.llmWords = this.serialize(chunk.llmWords);
+        if (chunk.routeUsed !== undefined)
+            updateHash.routeUsed = chunk.routeUsed;
+        if (chunk.sttHistory !== undefined)
+            updateHash.sttHistory = this.serialize(chunk.sttHistory);
+        p.hset(key, updateHash);
         p.expire(key, EXPIRATION);
         await p.exec();
         return chunk;
@@ -211,6 +231,36 @@ class MulingstreamChunkManager {
             c.finalTranscription = transcription;
         });
     }
+    /**
+     * Update chunk with LLM-sanitized transcription from SmartTranslate.
+     * If the sanitized text differs from the original, sets transcriptionSource to 'llm'
+     * and updates finalTranscription to the sanitized version.
+     * Returns the chunk (caller can compare original vs sanitized to decide on TRANSCRIPTION_CORRECTED).
+     */
+    async updateLlmTranscription(roomId, n, opts) {
+        let wasChanged = false;
+        const chunk = await this.withChunk(roomId, n, (c) => {
+            const originalText = c.finalTranscription;
+            c.llmTranscription = opts.llmTranscription;
+            c.llmWords = opts.llmWords;
+            c.routeUsed = opts.routeUsed;
+            // If LLM produced a different transcription, update the active text
+            if (opts.routeUsed === 'LLM' && opts.llmTranscription !== originalText) {
+                c.finalTranscription = opts.llmTranscription;
+                c.transcriptionSource = 'llm';
+                wasChanged = true;
+            }
+            // Append to STT history (keep last 3)
+            if (opts.sttHistoryEntry) {
+                if (!c.sttHistory)
+                    c.sttHistory = [];
+                c.sttHistory.push(opts.sttHistoryEntry);
+                if (c.sttHistory.length > 3)
+                    c.sttHistory = c.sttHistory.slice(-3);
+            }
+        });
+        return { chunk, wasChanged };
+    }
     async discardLanguage(roomId, n, lang) {
         return this.withChunk(roomId, n, (c) => {
             if (c.translation[lang])

package/dist/managers/smart-translate-context-manager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SmartTranslate Context Manager
+ *
+ * Manages previous chunk context in Redis for best-effort context injection.
+ * Each session stores up to 3 previous chunks (sanitized preferred, raw STT fallback).
+ *
+ * Redis key: smarttranslate:context:{sessionId}
+ * Type: List (LPUSH new entries, LTRIM to keep last 3)
+ * TTL: 12 hours (same as chunk expiration)
+ */
+import { RedisClient } from '../redis-client';
+export interface ContextChunk {
+    seq: number;
+    text: string;
+    san: boolean;
+    ts: number;
+}
+export declare class SmartTranslateContextManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private contextKey;
+    /**
+     * Get the last N context chunks for a session (best-effort).
+     * Returns whatever is available RIGHT NOW — doesn't wait for pending LLM results.
+     */
+    getContext(sessionId: string, maxChunks?: number): Promise<ContextChunk[]>;
+    /**
+     * Push a context entry for a chunk.
+     * If the chunk was LLM-sanitized, push the sanitized text (san: true).
+     * If bypassed/Azure, push the raw STT text (san: false).
+     *
+     * Also handles "upgrade" — if a raw entry exists for this seq and LLM result
+     * comes back later, we replace it with the sanitized version.
+     */
+    pushContext(sessionId: string, entry: ContextChunk): Promise<void>;
+    /**
+     * Push raw STT text as fallback context immediately when a chunk arrives.
+     * This ensures context is available even before LLM processing finishes.
+     */
+    pushRawContext(sessionId: string, seq: number, text: string): Promise<void>;
+    /**
+     * Upgrade a context entry with LLM-sanitized text.
+     * Called when LLM returns a result for a chunk that already has raw context.
+     */
+    pushSanitizedContext(sessionId: string, seq: number, sanitizedText: string): Promise<void>;
+    /**
+     * Clean up context for a session (called when streaming ends).
+     */
+    cleanupSession(sessionId: string): Promise<void>;
+}

package/dist/managers/smart-translate-context-manager.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * SmartTranslate Context Manager
+ *
+ * Manages previous chunk context in Redis for best-effort context injection.
+ * Each session stores up to 3 previous chunks (sanitized preferred, raw STT fallback).
+ *
+ * Redis key: smarttranslate:context:{sessionId}
+ * Type: List (LPUSH new entries, LTRIM to keep last 3)
+ * TTL: 12 hours (same as chunk expiration)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartTranslateContextManager = void 0;
+const CONTEXT_TTL = 12 * 60 * 60; // 12 hours
+const MAX_CONTEXT_CHUNKS = 3;
+class SmartTranslateContextManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    contextKey(sessionId) {
+        return `smarttranslate:context:${sessionId}`;
+    }
+    /**
+     * Get the last N context chunks for a session (best-effort).
+     * Returns whatever is available RIGHT NOW — doesn't wait for pending LLM results.
+     */
+    async getContext(sessionId, maxChunks = MAX_CONTEXT_CHUNKS) {
+        try {
+            const key = this.contextKey(sessionId);
+            const raw = await this.redisClient.lrange(key, 0, maxChunks - 1);
+            if (!raw || raw.length === 0)
+                return [];
+            return raw
+                .map((entry) => {
+                try {
+                    return JSON.parse(entry);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((c) => c !== null)
+                .reverse(); // LPUSH stores newest first, we want chronological order
+        }
+        catch (err) {
+            console.warn(`[SmartTranslateContextManager] getContext FAILED for ${sessionId}: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Push a context entry for a chunk.
+     * If the chunk was LLM-sanitized, push the sanitized text (san: true).
+     * If bypassed/Azure, push the raw STT text (san: false).
+     *
+     * Also handles "upgrade" — if a raw entry exists for this seq and LLM result
+     * comes back later, we replace it with the sanitized version.
+     */
+    async pushContext(sessionId, entry) {
+        try {
+            const key = this.contextKey(sessionId);
+            // Check if an entry for this seq already exists (raw fallback that we can upgrade)
+            const existing = await this.getContext(sessionId, MAX_CONTEXT_CHUNKS + 2);
+            const existingIdx = existing.findIndex((c) => c.seq === entry.seq);
+            if (existingIdx >= 0 && entry.san && !existing[existingIdx].san) {
+                // Upgrade: replace raw entry with sanitized version
+                // We need to rebuild the list (Redis list doesn't support random update easily)
+                existing[existingIdx] = entry;
+                const pipe = this.redisClient.pipeline();
+                pipe.del(key);
+                // Push in reverse order since LPUSH adds to head
+                for (let i = existing.length - 1; i >= 0; i--) {
+                    pipe.lpush(key, JSON.stringify(existing[i]));
+                }
+                pipe.ltrim(key, 0, MAX_CONTEXT_CHUNKS - 1);
+                pipe.expire(key, CONTEXT_TTL);
+                await pipe.exec();
+                return;
+            }
+            // Normal push: add new entry
+            if (existingIdx < 0) {
+                const pipe = this.redisClient.pipeline();
+                pipe.lpush(key, JSON.stringify(entry));
+                pipe.ltrim(key, 0, MAX_CONTEXT_CHUNKS - 1);
+                pipe.expire(key, CONTEXT_TTL);
+                await pipe.exec();
+            }
+        }
+        catch (err) {
+            console.warn(`[SmartTranslateContextManager] pushContext FAILED for ${sessionId}: ${err}`);
+        }
+    }
+    /**
+     * Push raw STT text as fallback context immediately when a chunk arrives.
+     * This ensures context is available even before LLM processing finishes.
+     */
+    async pushRawContext(sessionId, seq, text) {
+        await this.pushContext(sessionId, {
+            seq,
+            text,
+            san: false,
+            ts: Date.now()
+        });
+    }
+    /**
+     * Upgrade a context entry with LLM-sanitized text.
+     * Called when LLM returns a result for a chunk that already has raw context.
+     */
+    async pushSanitizedContext(sessionId, seq, sanitizedText) {
+        await this.pushContext(sessionId, {
+            seq,
+            text: sanitizedText,
+            san: true,
+            ts: Date.now()
+        });
+    }
+    /**
+     * Clean up context for a session (called when streaming ends).
+     */
+    async cleanupSession(sessionId) {
+        try {
+            await this.redisClient.del(this.contextKey(sessionId));
+        }
+        catch {
+            // Cleanup failure is non-critical
+        }
+    }
+}
+exports.SmartTranslateContextManager = SmartTranslateContextManager;

package/dist/redis-client.d.ts

@@ -38,6 +38,9 @@ export declare class RedisClient {
     incr(key: string): Promise<number>;
     scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
     keys(pattern: string): Promise<string[]>;
+    lpush(key: string, value: string): Promise<number>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    ltrim(key: string, start: number, stop: number): Promise<string>;
     pipeline(): ReturnType<IORedis['pipeline']>;
     unlink(...keys: string[]): Promise<number>;
     jsonSet<T>(key: string, path: string, value: T): Promise<string>;

package/dist/redis-client.js

@@ -109,6 +109,16 @@ class RedisClient {
     async keys(pattern) {
         return this.client.keys(pattern);
     }
+    // List operations (used by SmartTranslate context manager)
+    async lpush(key, value) {
+        return this.client.lpush(key, value);
+    }
+    async lrange(key, start, stop) {
+        return this.client.lrange(key, start, stop);
+    }
+    async ltrim(key, start, stop) {
+        return this.client.ltrim(key, start, stop);
+    }
     pipeline() {
         return this.client.pipeline();
     }

package/package.json

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