@mulingai-npm/redis 3.38.2 → 3.38.4

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

@@ -25,6 +25,11 @@ export type SttHistoryEntry = {
     source: 'stt' | 'llm';
     provider: string;
 };
+export type TranslationHint = {
+    type: string;
+    ref: string;
+    text: string;
+};
 export type MulingstreamChunkData = {
     chunkId: string;
     roomId: string;
@@ -34,6 +39,7 @@ export type MulingstreamChunkData = {
     targetLanguages: string[];
     shortCodeTargetLanguages: string[];
     finalTranscription: string;
+    sanitizedTranscription?: string;
     createdAt: number;
     creditUsageSessionId?: number | null;
     streamingChunk: StreamingChunkData;
@@ -41,6 +47,7 @@ export type MulingstreamChunkData = {
         [language: string]: {
             translation: string;
             status: StepStatus;
+            hints?: TranslationHint[];
         };
     };
     tts: {

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.2",
+    "version": "3.38.4",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {