@aj-archipelago/cortex 1.3.28 → 1.3.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.28",
+  "version": "1.3.29",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/pathways/translate_subtitle.js

@@ -2,7 +2,7 @@ import { parse, build } from "@aj-archipelago/subvibe";
 import logger from "../lib/logger.js";
 import { callPathway } from "../lib/pathwayTools.js";
 
-function splitIntoOverlappingChunks(captions, chunkSize = 20, overlap = 3) {
+export function splitIntoOverlappingChunks(captions, chunkSize = 20, overlap = 3) {
   const chunks = [];
   for (let i = 0; i < captions.length; i += (chunkSize - overlap)) {
     const end = Math.min(i + chunkSize, captions.length);
@@ -17,26 +17,51 @@ function splitIntoOverlappingChunks(captions, chunkSize = 20, overlap = 3) {
   return chunks;
 }
 
-function selectBestTranslation(translations, startIndex, endIndex) {
-  // If we only have one translation for this caption, use it
-  if (translations.length === 1) return translations[0];
+export function selectBestTranslation(translations, startIndex, endIndex) {
+  try {
+    if (!translations || !Array.isArray(translations)) {
+      logger.warn(`Invalid translations input: ${JSON.stringify(translations)}`);
+      return null;
+    }
+    
+    if (translations.length === 0) {
+      logger.warn(`No translations available for selection`);
+      return null;
+    }
+    
+    // If we only have one translation for this caption, use it
+    if (translations.length === 1) return translations[0];
 
-  // For multiple translations, prefer the one from the middle of its chunk
-  // This helps avoid edge effects in translation
-  return translations.reduce((best, current) => {
-    const currentDistance = Math.min(
-      Math.abs(current.chunkStart - startIndex),
-      Math.abs(current.chunkEnd - endIndex)
-    );
-    const bestDistance = Math.min(
-      Math.abs(best.chunkStart - startIndex),
-      Math.abs(best.chunkEnd - endIndex)
-    );
-    return currentDistance < bestDistance ? current : best;
-  });
+    // Use the first translation as a starting point
+    const first = translations[0];
+    
+    // For multiple translations, prefer the one whose identifier is closest to the middle
+    // of the requested range
+    const targetValue = (Number(startIndex) + Number(endIndex)) / 2;
+    
+    return translations.reduce((best, current) => {
+      try {
+        // Use identifier for comparison if available, otherwise use index
+        const currentValue = Number(current.identifier !== undefined ? current.identifier : current.index || 0);
+        const bestValue = Number(best.identifier !== undefined ? best.identifier : best.index || 0);
+        
+        const currentDistance = Math.abs(currentValue - targetValue);
+        const bestDistance = Math.abs(bestValue - targetValue);
+        
+        return currentDistance < bestDistance ? current : best;
+      } catch (err) {
+        logger.warn(`Error comparing translations: ${err.message}`);
+        return best; // Fallback to existing best on error
+      }
+    }, first);
+  } catch (err) {
+    logger.error(`Error in selectBestTranslation: ${err.message}`);
+    // Return the first translation if available, otherwise null
+    return translations && translations.length ? translations[0] : null;
+  }
 }
 
-async function translateChunk(chunk, args, maxRetries = 3) {
+export async function translateChunk(chunk, args, maxRetries = 3) {
   const chunkText = build(chunk.captions, { format: args.format, preserveIndexes: true });
   
   for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -82,7 +107,7 @@ export default {
   timeout: 3600,
   executePathway: async ({args}) => {
     try {
-      const { text, format = 'srt' } = args;
+      const { text, format = 'vtt' } = args;
       const parsed = parse(text, { format, preserveIndexes: true });
       const captions = parsed.cues;
   
@@ -101,16 +126,18 @@ export default {
       // Create a map of caption index to all its translations
       const translationMap = new Map();
       translatedChunks.flat().forEach(caption => {
-        if (!translationMap.has(caption.index)) {
-          translationMap.set(caption.index, []);
+        const identifier = caption.identifier || caption.index;
+        if (!translationMap.has(identifier)) {
+          translationMap.set(identifier, []);
         }
-        translationMap.get(caption.index).push(caption);
+        translationMap.get(identifier).push(caption);
       });
       
       // Select best translation for each caption
       const finalCaptions = captions.map(caption => {
-        const translations = translationMap.get(caption.index) || [caption];
-        const bestTranslation = selectBestTranslation(translations, caption.index, caption.index);
+        const identifier = caption.identifier || caption.index;
+        const translations = translationMap.get(identifier) || [caption];
+        const bestTranslation = selectBestTranslation(translations, identifier, identifier);
         const text = bestTranslation?.text || caption?.text;
         return { ...caption, text };
       });

package/server/plugins/openAiWhisperPlugin.js

@@ -72,13 +72,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
             if(maxLineWidth) tsparams.max_line_width = maxLineWidth;
             if(maxLineCount) tsparams.max_line_count = maxLineCount;
             if(maxWordsPerLine) tsparams.max_words_per_line = maxWordsPerLine;
-            if(wordTimestamped!=null) {
-                if(!wordTimestamped) {
-                    tsparams.word_timestamps = "False";
-                }else{
-                    tsparams.word_timestamps = wordTimestamped;    
-                }
-            }
+            tsparams.word_timestamps = !wordTimestamped ? "False" : wordTimestamped;
 
             const cortexRequest = new CortexRequest({ pathwayResolver });
             cortexRequest.url = WHISPER_TS_API_URL;
@@ -157,7 +151,8 @@ async function processURI(uri) {
 
     const intervalId = setInterval(() => sendProgress(true), 3000);
 
-    const useTS = WHISPER_TS_API_URL && (wordTimestamped || highlightWords);
+    //const useTS = WHISPER_TS_API_URL && (wordTimestamped || highlightWords); // use TS API only for word timestamped
+    const useTS = !!WHISPER_TS_API_URL; // use TS API always if URL is set
 
     if (useTS) {
         _promise = processTS;