@mulingai-npm/redis 3.40.24 → 3.40.26

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

@@ -65,6 +65,15 @@ export type MulingstreamChunkData = {
     transcriptionSource: 'stt' | 'llm';
     routeUsed?: 'LLM' | 'AZURE' | 'AZURE_FALLBACK';
     sttHistory?: SttHistoryEntry[];
+    /** Lifecycle status w.r.t. the pending-fragment buffer.
+     *  - 'EMITTED' (default): chunk produced sanitized output and translations.
+     *  - 'DEFERRED': chunk held back; its content lives in the pending buffer until consumed.
+     *  - 'USED': chunk's content was rolled into a later chunk's emission. */
+    bufferStatus?: 'EMITTED' | 'DEFERRED' | 'USED';
+    /** Trailing fragment buffered for the next chunk (set on DEFERRED rows). */
+    pendingText?: string;
+    /** Chunks whose deferred content was absorbed into this chunk's emission. */
+    consumedChunkNumbers?: number[];
 };
 export declare class MulingstreamChunkManager {
     private redisClient;
@@ -146,6 +155,16 @@ export declare class MulingstreamChunkManager {
         isEmitted?: boolean;
         duration?: number;
     }): Promise<MulingstreamChunkData | null>;
+    /**
+     * Update SmartTranslate buffering metadata on a chunk (Section 22).
+     * Writes `bufferStatus`, `pendingText`, and `consumedChunkNumbers` so the chunk row
+     * persisted at the end of the pipeline reflects whether it was DEFERRED / USED / EMITTED.
+     */
+    setBufferStatus(roomId: string, n: number, opt: {
+        bufferStatus?: 'EMITTED' | 'DEFERRED' | 'USED';
+        pendingText?: string;
+        consumedChunkNumbers?: 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)

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

@@ -342,6 +342,21 @@ class MulingstreamChunkManager {
                 e.duration = opt.duration;
         });
     }
+    /**
+     * Update SmartTranslate buffering metadata on a chunk (Section 22).
+     * Writes `bufferStatus`, `pendingText`, and `consumedChunkNumbers` so the chunk row
+     * persisted at the end of the pipeline reflects whether it was DEFERRED / USED / EMITTED.
+     */
+    async setBufferStatus(roomId, n, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            if (opt.bufferStatus !== undefined)
+                c.bufferStatus = opt.bufferStatus;
+            if (opt.pendingText !== undefined)
+                c.pendingText = opt.pendingText;
+            if (opt.consumedChunkNumbers !== undefined)
+                c.consumedChunkNumbers = opt.consumedChunkNumbers;
+        });
+    }
     async areTranslationsProcessed(roomId, n) {
         const c = await this.getMulingstreamChunkById(roomId, n);
         return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');

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

@@ -15,10 +15,22 @@ export interface ContextChunk {
     san: boolean;
     ts: number;
 }
+/**
+ * Pending buffer entry for the SmartTranslate buffering contract (Section 22).
+ * Stores the trailing fragment from the most-recent LLM response so it can be
+ * prepended to the next chunk's input.
+ */
+export interface PendingBuffer {
+    text: string;
+    seqs: number[];
+    consecutiveDeferred: number;
+    ts: number;
+}
 export declare class SmartTranslateContextManager {
     private redisClient;
     constructor(redisClient: RedisClient);
     private contextKey;
+    private pendingKey;
     /**
      * Get the last N context chunks for a session (best-effort).
      * Returns whatever is available RIGHT NOW — doesn't wait for pending LLM results.
@@ -47,4 +59,20 @@ export declare class SmartTranslateContextManager {
      * Clean up context for a session (called when streaming ends).
      */
     cleanupSession(sessionId: string): Promise<void>;
+    /**
+     * Read the current pending fragment for a session (best-effort).
+     * Returns null if no buffer is set or Redis is unavailable.
+     */
+    getPending(sessionId: string): Promise<PendingBuffer | null>;
+    /**
+     * Overwrite the pending fragment for a session.
+     * Pass an empty `text` to clear the buffer (a no-op write that effectively
+     * resets the deferred-chunk tracking).
+     */
+    setPending(sessionId: string, buffer: PendingBuffer): Promise<void>;
+    /**
+     * Clear the pending fragment unconditionally. Returns the cleared buffer (if any)
+     * so callers performing a session-end flush can emit the dropped fragment.
+     */
+    clearPending(sessionId: string): Promise<PendingBuffer | null>;
 }

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

@@ -20,6 +20,9 @@ class SmartTranslateContextManager {
     contextKey(sessionId) {
         return `smarttranslate:context:${sessionId}`;
     }
+    pendingKey(sessionId) {
+        return `smarttranslate:pending:${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.
@@ -122,10 +125,70 @@ class SmartTranslateContextManager {
     async cleanupSession(sessionId) {
         try {
             await this.redisClient.del(this.contextKey(sessionId));
+            await this.redisClient.del(this.pendingKey(sessionId));
         }
         catch {
             // Cleanup failure is non-critical
         }
     }
+    // ──────────────────────────────────────────────────────────────────────
+    //  Pending Buffer (Section 22 — Incomplete Chunk Merging / Buffering)
+    // ──────────────────────────────────────────────────────────────────────
+    /**
+     * Read the current pending fragment for a session (best-effort).
+     * Returns null if no buffer is set or Redis is unavailable.
+     */
+    async getPending(sessionId) {
+        try {
+            const raw = await this.redisClient.get(this.pendingKey(sessionId));
+            if (!raw)
+                return null;
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        }
+        catch (err) {
+            console.warn(`[SmartTranslateContextManager] getPending FAILED for ${sessionId}: ${err}`);
+            return null;
+        }
+    }
+    /**
+     * Overwrite the pending fragment for a session.
+     * Pass an empty `text` to clear the buffer (a no-op write that effectively
+     * resets the deferred-chunk tracking).
+     */
+    async setPending(sessionId, buffer) {
+        try {
+            const key = this.pendingKey(sessionId);
+            if (!buffer.text) {
+                await this.redisClient.del(key);
+                return;
+            }
+            const pipe = this.redisClient.pipeline();
+            pipe.set(key, JSON.stringify(buffer));
+            pipe.expire(key, CONTEXT_TTL);
+            await pipe.exec();
+        }
+        catch (err) {
+            console.warn(`[SmartTranslateContextManager] setPending FAILED for ${sessionId}: ${err}`);
+        }
+    }
+    /**
+     * Clear the pending fragment unconditionally. Returns the cleared buffer (if any)
+     * so callers performing a session-end flush can emit the dropped fragment.
+     */
+    async clearPending(sessionId) {
+        const current = await this.getPending(sessionId);
+        try {
+            await this.redisClient.del(this.pendingKey(sessionId));
+        }
+        catch (err) {
+            console.warn(`[SmartTranslateContextManager] clearPending FAILED for ${sessionId}: ${err}`);
+        }
+        return current;
+    }
 }
 exports.SmartTranslateContextManager = SmartTranslateContextManager;

package/package.json

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