@aj-archipelago/cortex 1.3.24 → 1.3.26

package/lib/pathwayTools.js

@@ -21,23 +21,25 @@ const callPathway = async (pathwayName, inArgs, pathwayResolver) => {
     let rootRequestId = pathwayResolver?.rootRequestId || pathwayResolver?.requestId;
 
     let data = await pathway.rootResolver(parent, {...args, rootRequestId}, { config, pathway, requestState } );
+    pathwayResolver && pathwayResolver.mergeResults(data);
+
+    let returnValue = data?.result || null;
 
     if (args.async || args.stream) {
         const { result: requestId } = data;
 
         // Fire the resolver for the async requestProgress
-        logger.info(`Callpathway starting async requestProgress, requestId: ${requestId}`);
+        logger.info(`Callpathway starting async requestProgress, pathway: ${pathwayName}, requestId: ${requestId}`);
         const { resolver, args } = requestState[requestId];
         requestState[requestId].useRedis = false;
         requestState[requestId].started = true;
 
-        data = resolver && await resolver(args);
+        resolver && await resolver(args);
+        
+        returnValue = null;
     }
     
-    // Update pathwayResolver with new data if available
-    pathwayResolver?.mergeResults(data);
-
-    return data?.result;
+    return returnValue;
 };
 
 const gpt3Encode = (text) => {
@@ -48,7 +50,7 @@ const gpt3Decode = (text) => {
     return decode(text);
 }
 
-const say = async (requestId, message, maxMessageLength = Infinity) => {
+const say = async (requestId, message, maxMessageLength = Infinity, voiceResponse = true) => {
     try {
         const chunks = getSemanticChunks(message, maxMessageLength);
 
@@ -60,11 +62,13 @@ const say = async (requestId, message, maxMessageLength = Infinity) => {
             });
         }
 
-        await publishRequestProgress({
-            requestId,
-            progress: 0.5,
-            data: " ... "
-        });
+        if (voiceResponse) {
+            await publishRequestProgress({
+                requestId,
+                progress: 0.5,
+                data: " ... "
+            });
+        }
 
         await publishRequestProgress({
             requestId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.24",
+  "version": "1.3.26",
   "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": {
@@ -33,7 +33,7 @@
   "type": "module",
   "homepage": "https://github.com/aj-archipelago/cortex#readme",
   "dependencies": {
-    "@aj-archipelago/subvibe": "^1.0.5",
+    "@aj-archipelago/subvibe": "^1.0.8",
     "@apollo/server": "^4.7.3",
     "@apollo/server-plugin-response-cache": "^4.1.2",
     "@apollo/utils.keyvadapter": "^3.0.0",

package/pathways/system/entity/sys_entity_continue.js

@@ -48,6 +48,10 @@ export default {
                 chatHistory: args.chatHistory.slice(-20)
             };
 
+            if (generatorPathway === 'coding') {
+                return;
+            }
+
             if (generatorPathway === 'sys_generator_document') {
                 generatorPathway = 'sys_generator_results';
                 newArgs.dataSources = ["mydata"];
@@ -57,11 +61,7 @@ export default {
             
             const result = await callPathway(generatorPathway, newArgs, resolver);
 
-            if (args.stream) {
-                return "";
-            }
-
-            if (!result) {
+            if (!result && !args.stream) {
                 result = await callPathway('sys_generator_error', { ...args, text: `Tried to use a tool (${generatorPathway}), but no result was returned`, stream: false }, resolver);
             }
 

package/pathways/system/entity/sys_entity_start.js

@@ -105,22 +105,12 @@ export default {
             }
         }
 
-        const fetchChatResponse = async (args, pathwayResolver) => {
-            const [chatResponse, chatTitleResponse] = await Promise.all([
-                callPathway('sys_generator_quick', {...args, model: styleModel}, pathwayResolver),
-                callPathway('chat_title', { ...args, chatHistory: chatHistoryBeforeMemory, stream: false}),
-            ]);
-
-            title = chatTitleResponse;
-
-            return chatResponse;
-        };
-
-        // start fetching the default response - we may need it later
+        // start fetching responses in parallel if not streaming
         let fetchChatResponsePromise;
         if (!args.stream) {
-            fetchChatResponsePromise = fetchChatResponse({ ...args, ackResponse }, pathwayResolver);
+            fetchChatResponsePromise = callPathway('sys_generator_quick', {...args, model: styleModel, ackResponse}, pathwayResolver);
         }
+        const fetchTitleResponsePromise = callPathway('chat_title', {...args, chatHistory: chatHistoryBeforeMemory, stream: false});
 
         const visionContentPresent = chatArgsHasImageUrl(args);
 
@@ -223,42 +213,43 @@ export default {
                 }
             }
 
+            title = await fetchTitleResponsePromise;
+
+            pathwayResolver.tool = JSON.stringify({ 
+                hideFromModel: toolCallbackName ? true : false, 
+                toolCallbackName, 
+                title,
+                search: toolCallbackName === 'sys_generator_results' ? true : false,
+                coding: toolCallbackName === 'coding' ? true : false,
+                codeRequestId,
+                toolCallbackId
+            });
+
             if (toolCallbackMessage) {
                 if (args.skipCallbackMessage) {
-                    pathwayResolver.tool = JSON.stringify({ hideFromModel: false, search: false, title });  
                     return await callPathway('sys_entity_continue', { ...args, stream: false, model: styleModel, generatorPathway: toolCallbackName }, pathwayResolver);
                 }
 
                 if (args.stream) {
                     if (!ackResponse) {
-                        await say(pathwayResolver.requestId, toolCallbackMessage || "One moment please.", 10);
+                        await say(pathwayResolver.requestId, toolCallbackMessage || "One moment please.", 10, args.voiceResponse ? true : false);
                     }
-                    pathwayResolver.tool = JSON.stringify({ hideFromModel: false, search: false, title });  
-                    await callPathway('sys_entity_continue', { ...args, stream: true, generatorPathway: toolCallbackName }, pathwayResolver);
-                    return "";
+                    await callPathway('sys_entity_continue', { ...args, stream: true, generatorPathway: toolCallbackName }, pathwayResolver); 
+                    return;
                 }
                 
-                pathwayResolver.tool = JSON.stringify({ 
-                    hideFromModel: toolCallbackName ? true : false, 
-                    toolCallbackName, 
-                    title,
-                    search: toolCallbackName === 'sys_generator_results' ? true : false,
-                    coding: toolCallbackName === 'coding' ? true : false,
-                    codeRequestId,
-                    toolCallbackId
-                });
                 return toolCallbackMessage || "One moment please.";
             }
 
-            const chatResponse = await (fetchChatResponsePromise || fetchChatResponse({ ...args, ackResponse }, pathwayResolver));
+            const chatResponse = await (fetchChatResponsePromise || callPathway('sys_generator_quick', {...args, model: styleModel, ackResponse}, pathwayResolver));
             pathwayResolver.tool = JSON.stringify({ search: false, title });
-            return args.stream ? "" : chatResponse;
+            return args.stream ? null : chatResponse;
 
         } catch (e) {
             pathwayResolver.logError(e);
-            const chatResponse = await (fetchChatResponsePromise || fetchChatResponse({ ...args, ackResponse }, pathwayResolver));
+            const chatResponse = await (fetchChatResponsePromise || callPathway('sys_generator_quick', {...args, model: styleModel, ackResponse}, pathwayResolver));
             pathwayResolver.tool = JSON.stringify({ search: false, title });
-            return args.stream ? "" : chatResponse;
+            return args.stream ? null : chatResponse;
         }
     }
 };

package/pathways/system/entity/sys_generator_results.js

@@ -341,7 +341,7 @@ Here are the information sources that were found:
                 clearTimeout(timeoutId);
             }
             
-            if (!args.stream) {
+            if (!args.voiceResponse) {
                 const referencedSources = extractReferencedSources(result);
                 searchResults = searchResults.length ? pruneSearchResults(searchResults, referencedSources) : [];
             }

package/pathways/transcribe_gemini.js

@@ -5,283 +5,6 @@ import { Prompt } from "../server/prompt.js";
 
 const OFFSET_CHUNK = 500; //seconds of each chunk offset, only used if helper does not provide
 
-export function convertSrtToVtt(data) {
-    if (!data || !data.trim()) {
-        return "WEBVTT\n\n";
-    }
-
-    // If it's already VTT format and has header
-    if (data.trim().startsWith("WEBVTT")) {
-        const lines = data.split("\n");
-        const result = ["WEBVTT", ""]; // Start with header and blank line
-        let currentCue = [];
-
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-
-            // Skip empty lines and the WEBVTT header
-            if (!line || line === "WEBVTT") {
-                continue;
-            }
-
-            // If it's a number by itself, it's a cue identifier
-            if (/^\d+$/.test(line)) {
-                // If we have a previous cue, add it with proper spacing
-                if (currentCue.length > 0) {
-                    result.push(currentCue.join("\n"));
-                    result.push(""); // Add blank line between cues
-                    currentCue = [];
-                }
-                currentCue.push(line);
-                continue;
-            }
-
-            // Check for and convert timestamps
-            const fullTimeRegex = /^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/;
-            const shortTimeRegex = /^(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2})[,.](\d{3})$/;
-            const ultraShortTimeRegex = /^(\d{1,2})[.](\d{3})\s*-->\s*(\d{1,2})[.](\d{3})$/;
-
-            const fullMatch = line.match(fullTimeRegex);
-            const shortMatch = line.match(shortTimeRegex);
-            const ultraShortMatch = line.match(ultraShortTimeRegex);
-
-            if (fullMatch) {
-                // Already in correct format, just convert comma to dot
-                const convertedTime = line.replace(/,/g, '.');
-                currentCue.push(convertedTime);
-            } else if (shortMatch) {
-                // Convert MM:SS to HH:MM:SS
-                const convertedTime = `00:${shortMatch[1]}:${shortMatch[2]}.${shortMatch[3]} --> 00:${shortMatch[4]}:${shortMatch[5]}.${shortMatch[6]}`;
-                currentCue.push(convertedTime);
-            } else if (ultraShortMatch) {
-                // Convert SS to HH:MM:SS
-                const convertedTime = `00:00:${ultraShortMatch[1].padStart(2, '0')}.${ultraShortMatch[2]} --> 00:00:${ultraShortMatch[3].padStart(2, '0')}.${ultraShortMatch[4]}`;
-                currentCue.push(convertedTime);
-            } else if (!line.includes('-->')) {
-                // Must be subtitle text
-                currentCue.push(line);
-            }
-        }
-
-        // Add the last cue if there is one
-        if (currentCue.length > 0) {
-            result.push(currentCue.join("\n"));
-            result.push(""); // Add final blank line
-        }
-
-        // Join with newlines and ensure proper ending
-        return result.join("\n") + "\n";
-    }
-
-    // remove dos newlines and trim
-    var srt = data.replace(/\r+/g, "");
-    srt = srt.replace(/^\s+|\s+$/g, "");
-
-    // Split into cues and filter out empty ones
-    var cuelist = srt.split("\n\n").filter(cue => cue.trim());
-
-    // Always add WEBVTT header
-    var result = "WEBVTT\n\n";
-
-    // Convert each cue to VTT format
-    for (const cue of cuelist) {
-        const lines = cue.split("\n").map(line => line.trim()).filter(line => line);
-        if (lines.length < 2) continue;
-
-        let output = [];
-        
-        // Handle cue identifier
-        if (/^\d+$/.test(lines[0])) {
-            output.push(lines[0]);
-            lines.shift();
-        }
-
-        // Handle timestamp line
-        const timeLine = lines[0];
-        const fullTimeRegex = /^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/;
-        const shortTimeRegex = /^(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2})[,.](\d{3})$/;
-        const ultraShortTimeRegex = /^(\d{1,2})[.](\d{3})\s*-->\s*(\d{1,2})[.](\d{3})$/;
-
-        const fullMatch = timeLine.match(fullTimeRegex);
-        const shortMatch = timeLine.match(shortTimeRegex);
-        const ultraShortMatch = timeLine.match(ultraShortTimeRegex);
-
-        if (fullMatch) {
-            output.push(timeLine.replace(/,/g, '.'));
-        } else if (shortMatch) {
-            output.push(`00:${shortMatch[1]}:${shortMatch[2]}.${shortMatch[3]} --> 00:${shortMatch[4]}:${shortMatch[5]}.${shortMatch[6]}`);
-        } else if (ultraShortMatch) {
-            output.push(`00:00:${ultraShortMatch[1].padStart(2, '0')}.${ultraShortMatch[2]} --> 00:00:${ultraShortMatch[3].padStart(2, '0')}.${ultraShortMatch[4]}`);
-        } else {
-            continue; // Invalid timestamp format
-        }
-
-        // Add remaining lines as subtitle text
-        output.push(...lines.slice(1));
-        
-        // Add the cue to result
-        result += output.join("\n") + "\n\n";
-    }
-
-    return result;
-}
-
-function convertSrtCue(caption) {
-    if (!caption || !caption.trim()) {
-        return "";
-    }
-
-    var cue = "";
-    var s = caption.split(/\n/);
-
-    // concatenate multi-line string separated in array into one
-    while (s.length > 3) {
-        for (var i = 3; i < s.length; i++) {
-            s[2] += "\n" + s[i];
-        }
-        s.splice(3, s.length - 3);
-    }
-
-    var line = 0;
-
-    // detect identifier
-    if (
-        s[0] &&
-        s[1] &&
-        !s[0].match(/\d+:\d+:\d+/) &&
-        s[1].match(/\d+:\d+:\d+/)
-    ) {
-        const match = s[0].match(/^\d+$/); // Only match if the entire line is a number
-        if (match) {
-            cue += match[0] + "\n";
-            line += 1;
-        }
-    }
-
-    // get time strings
-    if (s[line] && s[line].match(/\d+:\d+:\d+/)) {
-        // convert time string
-        var m = s[line].match(
-            /(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*--?>\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})/,
-        );
-        if (m) {
-            cue +=
-                m[1] +
-                ":" +
-                m[2] +
-                ":" +
-                m[3] +
-                "." +
-                m[4] +
-                " --> " +
-                m[5] +
-                ":" +
-                m[6] +
-                ":" +
-                m[7] +
-                "." +
-                m[8] +
-                "\n";
-            line += 1;
-        } else {
-            // Try alternate timestamp format
-            m = s[line].match(
-                /(\d{2}):(\d{2})\.(\d{3})\s*--?>\s*(\d{2}):(\d{2})\.(\d{3})/,
-            );
-            if (m) {
-                // Convert to full timestamp format
-                cue +=
-                    "00:" +
-                    m[1] +
-                    ":" +
-                    m[2] +
-                    "." +
-                    m[3] +
-                    " --> " +
-                    "00:" +
-                    m[4] +
-                    ":" +
-                    m[5] +
-                    "." +
-                    m[6] +
-                    "\n";
-                line += 1;
-            } else {
-                // Unrecognized timestring
-                return "";
-            }
-        }
-    } else {
-        // file format error or comment lines
-        return "";
-    }
-
-    // get cue text
-    if (s[line]) {
-        cue += s[line] + "\n\n";
-    }
-
-    return cue;
-}
-
-export function detectSubtitleFormat(text) {
-    // Remove DOS newlines and trim whitespace
-    const cleanText = text.replace(/\r+/g, "").trim();
-    const lines = cleanText.split("\n");
-
-    // Check if it's VTT format - be more lenient with the header
-    if (lines[0]?.trim() === "WEBVTT") {
-        return "vtt";
-    }
-
-    // Define regex patterns for timestamp formats
-    const srtTimeRegex =
-        /(\d{2}:\d{2}:\d{2})[,.]\d{3}\s*-->\s*(\d{2}:\d{2}:\d{2})[,.]\d{3}/;
-    const vttTimeRegex =
-        /(?:\d{2}:)?(\d{1,2})[.]\d{3}\s*-->\s*(?:\d{2}:)?(\d{1,2})[.]\d{3}/;
-
-    let hasSrtTimestamps = false;
-    let hasVttTimestamps = false;
-    let hasSequentialNumbers = false;
-    let lastNumber = 0;
-
-    // Look through first few lines to detect patterns
-    for (let i = 0; i < Math.min(lines.length, 12); i++) {
-        const line = lines[i]?.trim();
-        if (!line) continue;
-
-        // Check for timestamps
-        if (srtTimeRegex.test(line)) {
-            hasSrtTimestamps = true;
-        }
-        if (vttTimeRegex.test(line)) {
-            hasVttTimestamps = true;
-        }
-
-        // Check for sequential numbers
-        const numberMatch = line.match(/^(\d+)$/);
-        if (numberMatch) {
-            const num = parseInt(numberMatch[1]);
-            if (lastNumber === 0 || num === lastNumber + 1) {
-                hasSequentialNumbers = true;
-                lastNumber = num;
-            }
-        }
-    }
-
-    // If it has SRT-style timestamps (HH:MM:SS), it's SRT
-    if (hasSrtTimestamps && hasSequentialNumbers) {
-        return "srt";
-    }
-
-    // If it has VTT-style timestamps (MM:SS) or WEBVTT header, it's VTT
-    if (hasVttTimestamps) {
-        return "vtt";
-    }
-
-    return null;
-}
-
 export default {
     prompt:
     [
@@ -381,7 +104,7 @@ export default {
 
         function getMessages(file, format) {
 
-            const responseFormat = format!== 'text' ? 'SRT' : 'text';
+            const responseFormat = format!== 'text' ? 'VTT' : 'text';
 
             const messages = [
                 {"role": "system", "content": `Instructions:\nYou are an AI entity with expertise of transcription. Your response only contains the transcription, no comments or additonal stuff. 
@@ -491,26 +214,8 @@ Even a single newline or space can cause the response to be rejected. You must f
         // }
         
         const result = await processChunksParallel(chunks, args);
-
-        // publishRequestProgress({
-        //     requestId: this.rootRequestId || this.requestId,
-        //     progress: 1,
-        //     data: "a",
-        // });
         
         if (['srt','vtt'].includes(responseFormat) || wordTimestamped) { // align subtitles for formats
-
-            
-
-            // convert as gemini output is unstable
-            for(let i = 0; i < result.length; i++) {
-                try{
-                    result[i] = convertSrtToVtt(result[i]);
-                }catch(error){
-                    logger.error(`Error converting to vtt: ${error}`);
-                }
-            }
-
             const offsets = chunks.map((chunk, index) => chunk?.offset || index * OFFSET_CHUNK);
             return alignSubtitles(result, responseFormat, offsets);
         }

package/pathways/translate_subtitle.js

@@ -1,95 +1,7 @@
+import { parse, build } from "@aj-archipelago/subvibe";
 import logger from "../lib/logger.js";
 import { callPathway } from "../lib/pathwayTools.js";
 
-function preprocessStr(str, format) {
-  try {
-    if (!str) return "";
-    let content = str
-      // Normalize line endings
-      .replace(/\r\n?/g, "\n")
-      // Remove WEBVTT header for processing
-      .replace(/^WEBVTT\n\n/, '');
-
-    // For SRT, convert commas to dots in timestamps
-    if (format === 'srt') {
-      content = content.replace(/(\d{2}:\d{2}:\d{2}),(\d{3})/g, "$1.$2");
-    }
-
-    return content
-      // Ensure each subtitle block is properly separated
-      .split(/\n\s*\n/)
-      .map(block => block.trim())
-      .filter(block => {
-        // Match both numeric indices (SRT) and optional caption identifiers (VTT)
-        const firstLine = block.split('\n')[0];
-        return block && (
-          /^\d+$/.test(firstLine) || // SRT style
-          /^\d{2}:\d{2}/.test(firstLine) || // VTT style without identifier
-          /^[^\n]+\n\d{2}:\d{2}/.test(block) // VTT style with identifier
-        );
-      })
-      .join("\n\n")
-      + "\n\n";
-  } catch (e) {
-    logger.error(`An error occurred in content text preprocessing: ${e}`);
-    return "";
-  }
-}
-
-function timeToMs(timeStr) {
-  const [time, ms] = timeStr.split(/[.,]/);
-  const [hours, minutes, seconds] = time.split(':').map(Number);
-  return (hours * 3600 + minutes * 60 + seconds) * 1000 + parseInt(ms);
-}
-
-function msToTimestamp(ms, format) {
-  const date = new Date(ms);
-  const timestamp = date.toISOString().slice(11, 23);
-  return format === 'srt' ? timestamp.replace('.', ',') : timestamp;
-}
-
-function parseSubtitles(content, format) {
-  const blocks = content.split(/\n\s*\n/).filter(block => block.trim());
-  const captions = [];
-  
-  for (const block of blocks) {
-    const lines = block.split('\n');
-    if (lines.length < 2) continue;
-    
-    let index, timelineIndex;
-    if (format === 'srt') {
-      // SRT format: numeric index required
-      if (!/^\d+$/.test(lines[0])) continue;
-      index = parseInt(lines[0]);
-      timelineIndex = 1;
-    } else {
-      // VTT format: optional identifier
-      timelineIndex = /^\d{2}:\d{2}/.test(lines[0]) ? 0 : 1;
-      index = timelineIndex === 0 ? captions.length + 1 : lines[0];
-    }
-    
-    const timeMatch = lines[timelineIndex].match(/^(\d{2}:\d{2}:\d{2}[.,]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[.,]\d{3})/);
-    if (!timeMatch) continue;
-    
-    const startTime = timeMatch[1].replace(',', '.');
-    const endTime = timeMatch[2].replace(',', '.');
-    const content = lines.slice(timelineIndex + 1).join('\n');
-    
-    captions.push({
-      type: "caption",
-      index: typeof index === 'number' ? index : captions.length + 1,
-      identifier: typeof index === 'string' ? index : null,
-      start: timeToMs(startTime),
-      end: timeToMs(endTime),
-      duration: timeToMs(endTime) - timeToMs(startTime),
-      content: content,
-      text: content
-    });
-  }
-  
-  return captions;
-}
-
 function splitIntoOverlappingChunks(captions, chunkSize = 20, overlap = 3) {
   const chunks = [];
   for (let i = 0; i < captions.length; i += (chunkSize - overlap)) {
@@ -124,88 +36,8 @@ function selectBestTranslation(translations, startIndex, endIndex) {
   });
 }
 
-function validateFinalOutput(result, originalText, format) {
-  // Basic structure validation
-  if (!result || !result.trim()) {
-    logger.error("Empty or whitespace-only result");
-    return false;
-  }
-  
-  // Check for VTT header if needed
-  if (format === 'vtt' && !result.startsWith('WEBVTT\n\n')) {
-    logger.error("Missing WEBVTT header");
-    return false;
-  }
-  
-  // Check for timestamp format
-  const timestampPattern = format === 'srt' 
-    ? /\d{2}:\d{2}:\d{2},\d{3}\s*-->\s*\d{2}:\d{2}:\d{2},\d{3}/
-    : /\d{2}:\d{2}:\d{2}\.\d{3}\s*-->\s*\d{2}:\d{2}:\d{2}\.\d{3}/;
-  
-  const hasTimestamps = timestampPattern.test(result);
-  if (!hasTimestamps) {
-    logger.error(`No valid ${format.toUpperCase()} timestamps found in result`);
-    return false;
-  }
-
-  // Check overall length ratio
-  if (result.length < originalText.length * 0.5) {
-    logger.error(`Result length (${result.length}) is less than 50% of original length (${originalText.length})`);
-    return false;
-  }
-
-  // Validate subtitle block structure
-  const blocks = result.split(/\n\s*\n/).filter(block => block.trim());
-  
-  // Skip WEBVTT header for VTT format
-  const startIndex = format === 'vtt' && blocks[0].trim() === 'WEBVTT' ? 1 : 0;
-  
-  for (let i = startIndex; i < blocks.length; i++) {
-    const block = blocks[i];
-    const lines = block.trim().split('\n');
-    
-    if (lines.length < 2) {
-      logger.error(`Block ${i + 1} has insufficient lines (${lines.length}):\n${block}`);
-      return false;
-    }
-    
-    // Find the timestamp line
-    let timestampLineIndex = -1;
-    for (let j = 0; j < lines.length; j++) {
-      if (timestampPattern.test(lines[j])) {
-        timestampLineIndex = j;
-        break;
-      }
-    }
-    
-    if (timestampLineIndex === -1) {
-      logger.error(`Block ${i + 1} has no valid timestamp line:\n${block}`);
-      return false;
-    }
-    
-    // Check that we have content after the timestamp
-    if (timestampLineIndex === lines.length - 1) {
-      logger.error(`Block ${i + 1} has no content after timestamp:\n${block}`);
-      return false;
-    }
-    
-    // Log the content for inspection
-    logger.debug(`Block ${i + 1} content:\n${lines.slice(timestampLineIndex + 1).join('\n')}`);
-  }
-
-  return true;
-}
-
 async function translateChunk(chunk, args, maxRetries = 3) {
-  const format = args.format || 'srt';
-  const chunkText = chunk.captions
-    .map(c => {
-      const startTime = msToTimestamp(c.start, format);
-      const endTime = msToTimestamp(c.end, format);
-      const index = format === 'srt' || !c.identifier ? c.index : c.identifier;
-      return `${index}\n${startTime} --> ${endTime}\n${c.content}`;
-    })
-    .join('\n\n');
+  const chunkText = build(chunk.captions, { format: args.format, preserveIndexes: true });
   
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {
@@ -223,61 +55,9 @@ async function translateChunk(chunk, args, maxRetries = 3) {
       }
       
       const content = match[1].trim();
-      const blocks = content.split(/\n\s*\n/);
-      
-      // Check if any blocks are empty or invalid
-      let hasEmptyBlocks = false;
-      const processedBlocks = chunk.captions.map((caption, index) => {
-        const block = blocks[index];
-        if (!block) {
-          logger.warn(`Attempt ${attempt + 1}: Empty block for caption ${caption.index}`);
-          hasEmptyBlocks = true;
-          return null;
-        }
-        
-        const lines = block.split('\n');
-        if (lines.length < 3) {
-          logger.warn(`Attempt ${attempt + 1}: Invalid block structure for caption ${caption.index}`);
-          hasEmptyBlocks = true;
-          return null;
-        }
-        
-        const content = lines.slice(2).join('\n').trim();
-        if (!content) {
-          logger.warn(`Attempt ${attempt + 1}: Empty content for caption ${caption.index}`);
-          hasEmptyBlocks = true;
-          return null;
-        }
-        
-        return {
-          ...caption,
-          content: content,
-          text: content,
-          chunkStart: chunk.startIndex,
-          chunkEnd: chunk.endIndex
-        };
-      });
-      
-      // If no empty blocks, return the processed blocks
-      if (!hasEmptyBlocks) {
-        return processedBlocks;
-      }
-      
-      // If this was the last attempt and we still have empty blocks,
-      // return what we have but keep original content for empty blocks
-      if (attempt === maxRetries - 1) {
-        logger.warn(`Failed to get valid translations for all blocks after ${maxRetries} attempts`);
-        return chunk.captions.map((caption, index) => {
-          return processedBlocks[index] || {
-            ...caption,
-            chunkStart: chunk.startIndex,
-            chunkEnd: chunk.endIndex
-          };
-        });
-      }
-      
-      // Otherwise, try again
-      logger.info(`Retrying chunk due to empty blocks (attempt ${attempt + 1}/${maxRetries})`);
+
+      const parsed = parse(content, { preserveIndexes: true });
+      return parsed.cues;
       
     } catch (e) {
       logger.error(`Error translating chunk ${chunk.startIndex}-${chunk.endIndex} (attempt ${attempt + 1}): ${e}`);
@@ -303,8 +83,8 @@ export default {
   executePathway: async ({args}) => {
     try {
       const { text, format = 'srt' } = args;
-      const preprocessedText = preprocessStr(text, format);
-      const captions = parseSubtitles(preprocessedText, format);
+      const parsed = parse(text, { format, preserveIndexes: true });
+      const captions = parsed.cues;
   
       if (!captions || captions.length === 0) {
         throw new Error("No captions found in input");
@@ -330,40 +110,12 @@ export default {
       // Select best translation for each caption
       const finalCaptions = captions.map(caption => {
         const translations = translationMap.get(caption.index) || [caption];
-        return selectBestTranslation(translations, caption.index, caption.index);
+        const bestTranslation = selectBestTranslation(translations, caption.index, caption.index);
+        const text = bestTranslation?.text || caption?.text;
+        return { ...caption, text };
       });
-      
-      // Format the output
-      let result = finalCaptions
-        .map(caption => {
-          const startTime = msToTimestamp(caption.start, format);
-          const endTime = msToTimestamp(caption.end, format);
-          // Only include index/identifier if it was in the original
-          const hasIdentifier = caption.identifier !== null || format === 'srt';
-          const index = format === 'srt' || !caption.identifier ? caption.index : caption.identifier;
-          return hasIdentifier ? 
-            `${index}\n${startTime} --> ${endTime}\n${caption.content}` :
-            `${startTime} --> ${endTime}\n${caption.content}`;
-        })
-        .join('\n\n')
-        .trim();
-
-      // Add final newline only if input had one
-      if (text.endsWith('\n')) {
-        result += '\n';
-      }
-
-      // Add WEBVTT header for VTT format
-      if (format === 'vtt') {
-        result = 'WEBVTT\n\n' + result;
-      }
-
-      // Validate final output
-      if (!validateFinalOutput(result, text, format)) {
-        throw new Error("Final subtitle reconstruction failed validation");
-      }
 
-      return result;
+      return build(finalCaptions, { format, preserveIndexes: true });
     } catch (e) {
       logger.error(`Subtitle translation failed: ${e}`);
       throw e;

package/server/pathwayResolver.js

@@ -83,43 +83,23 @@ class PathwayResolver {
             if (requestProgress.progress === 1 && this.rootRequestId) {
                 delete requestProgress.progress;
             }
-            publishRequestProgress(requestProgress);
+            publishRequestProgress({...requestProgress, info: this.tool || ''});
         }
 
         try {
             responseData = await this.executePathway(args);
         }
         catch (error) {
-            if (!args.async) {
-                publishRequestProgress({
-                    requestId: this.rootRequestId || this.requestId,
-                    progress: 1,
-                    data: '[DONE]',
-                });
-            } else {
-                publishRequestProgress({
-                    requestId: this.rootRequestId || this.requestId,
-                    progress: 1,
-                    data: error.message || error.toString(),
-                });
-            }
+            publishRequestProgress({
+                requestId: this.rootRequestId || this.requestId,
+                progress: 1,
+                data: '',
+                info: 'ERROR: ' + error.message || error.toString()
+            });
         }
 
-        // If the response is a string, it's a regular long running response
-        if (args.async || typeof responseData === 'string') {
-            const { completedCount=1, totalCount=1 } = requestState[this.requestId];
-            requestState[this.requestId].data = responseData;
-            
-            // some models don't support progress updates
-            if (!modelTypesExcludedFromProgressUpdates.includes(this.model.type)) {
-                await publishNestedRequestProgress({
-                        requestId: this.rootRequestId || this.requestId,
-                        progress: Math.min(completedCount,totalCount) / totalCount,
-                        data: JSON.stringify(responseData),
-                });
-            }
-        // If the response is an object, it's a streaming response
-        } else {
+        // If the response is a stream, handle it as streaming response
+        if (responseData && typeof responseData.on === 'function') {
             try {
                 const incomingMessage = responseData;
                 let streamEnded = false;
@@ -184,11 +164,25 @@ class PathwayResolver {
                 publishRequestProgress({
                     requestId: this.requestId,
                     progress: 1,
-                    data: '[DONE]',
+                    data: '',
+                    info: 'ERROR: Stream read failed'
                 });
             } else {
                 return;
             }
+        } else {
+            const { completedCount = 1, totalCount = 1 } = requestState[this.requestId];
+            requestState[this.requestId].data = responseData;
+            
+            // some models don't support progress updates
+            if (!modelTypesExcludedFromProgressUpdates.includes(this.model.type)) {
+                await publishNestedRequestProgress({
+                        requestId: this.rootRequestId || this.requestId,
+                        progress: Math.min(completedCount, totalCount) / totalCount,
+                        data: responseData,
+                        info: this.tool || ''
+                });
+            }
         }
     }
 
@@ -197,7 +191,13 @@ class PathwayResolver {
             this.previousResult = mergeData.previousResult ? mergeData.previousResult : this.previousResult;
             this.warnings = [...this.warnings, ...(mergeData.warnings || [])];
             this.errors = [...this.errors, ...(mergeData.errors || [])];
-            this.tool = mergeData.tool || this.tool;
+            try {
+                const mergeDataTool = typeof mergeData.tool === 'string' ? JSON.parse(mergeData.tool) : mergeData.tool || {};
+                const thisTool = typeof this.tool === 'string' ? JSON.parse(this.tool) : this.tool || {};
+                this.tool = JSON.stringify({ ...thisTool, ...mergeDataTool });
+            } catch (error) {
+                logger.warn('Error merging pathway resolver tool objects: ' + error);
+            }
         }
     }
 

package/tests/translate_srt.test.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import fs from 'fs';
 import path from 'path';
+import { SubtitleUtils } from '@aj-archipelago/subvibe';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -45,12 +46,50 @@ async function testSubtitleTranslation(t, text, language = 'English', format = '
     // Check timestamps based on format
     const timestampPattern = format === 'srt' 
         ? /\d{2}:\d{2}:\d{2},\d{3} --> \d{2}:\d{2}:\d{2},\d{3}/g
-        : /\d{2}:\d{2}:\d{2}\.\d{3} --> \d{2}:\d{2}:\d{2}\.\d{3}/g;
+        : /(?:\d{2}:)?\d{2}:\d{2}\.\d{3} --> (?:\d{2}:)?\d{2}:\d{2}\.\d{3}/g;
 
     const originalTimestamps = text.match(timestampPattern);
     const translatedTimestamps = result.match(timestampPattern);
+
+    // Compare timestamps using SubtitleUtils.parseLooseTime
+    const areTimestampsEquivalent = originalTimestamps?.every((timestamp, index) => {
+        const [origStart, origEnd] = timestamp.split(' --> ');
+        const [transStart, transEnd] = translatedTimestamps[index].split(' --> ');
+        
+        const origStartTime = SubtitleUtils.parseLooseTime(origStart);
+        const origEndTime = SubtitleUtils.parseLooseTime(origEnd);
+        const transStartTime = SubtitleUtils.parseLooseTime(transStart);
+        const transEndTime = SubtitleUtils.parseLooseTime(transEnd);
+        
+        return origStartTime === transStartTime && origEndTime === transEndTime;
+    });
+
+    if (!areTimestampsEquivalent) {
+        const differences = originalTimestamps?.map((timestamp, index) => {
+            const [origStart, origEnd] = timestamp.split(' --> ');
+            const [transStart, transEnd] = translatedTimestamps[index].split(' --> ');
+            
+            const origStartTime = SubtitleUtils.parseLooseTime(origStart);
+            const origEndTime = SubtitleUtils.parseLooseTime(origEnd);
+            const transStartTime = SubtitleUtils.parseLooseTime(transStart);
+            const transEndTime = SubtitleUtils.parseLooseTime(transEnd);
+            
+            if (origStartTime !== transStartTime || origEndTime !== transEndTime) {
+                return {
+                    index,
+                    original: timestamp,
+                    translated: translatedTimestamps[index],
+                    parsedOriginal: { start: origStartTime, end: origEndTime },
+                    parsedTranslated: { start: transStartTime, end: transEndTime }
+                };
+            }
+            return null;
+        }).filter(Boolean);
+
+        console.log('Timestamp differences found:', differences);
+    }
     
-    t.deepEqual(originalTimestamps, translatedTimestamps, 'All timestamps should be present and unchanged');
+    t.true(areTimestampsEquivalent, 'All timestamps should be equivalent when parsed');
 
     // Check line count (accounting for WEBVTT header in VTT)
     const originalLineCount = text.split('\n').length;

package/tests/transcribe_gemini.test.js

@@ -1,217 +0,0 @@
-import test from 'ava';
-import { convertSrtToVtt } from '../pathways/transcribe_gemini.js';
-
-test('should return empty WebVTT for null or empty input', t => {
-    t.is(convertSrtToVtt(null), "WEBVTT\n\n");
-    t.is(convertSrtToVtt(''), "WEBVTT\n\n");
-    t.is(convertSrtToVtt('   '), "WEBVTT\n\n");
-});
-
-test('should convert basic SRT to WebVTT format', t => {
-    const srtInput = 
-`1
-00:00:01,000 --> 00:00:04,000
-Hello world`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:01.000 --> 00:00:04.000
-Hello world
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should convert multiple subtitle entries', t => {
-    const srtInput = 
-`1
-00:00:01,000 --> 00:00:04,000
-First subtitle
-
-2
-00:00:05,000 --> 00:00:08,000
-Second subtitle`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:01.000 --> 00:00:04.000
-First subtitle
-
-2
-00:00:05.000 --> 00:00:08.000
-Second subtitle
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle DOS line endings', t => {
-    const srtInput = "1\r\n00:00:01,000 --> 00:00:04,000\r\nHello world\r\n";
-    const expectedOutput = "WEBVTT\n\n1\n00:00:01.000 --> 00:00:04.000\nHello world\n\n";
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle multi-line subtitles', t => {
-    const srtInput = 
-`1
-00:00:01,000 --> 00:00:04,000
-First line
-Second line
-Third line
-
-2
-00:00:05,000 --> 00:00:08,000
-Another subtitle`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:01.000 --> 00:00:04.000
-First line
-Second line
-Third line
-
-2
-00:00:05.000 --> 00:00:08.000
-Another subtitle
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle invalid timestamp formats', t => {
-    const srtInput = 
-`1
-invalid timestamp
-Hello world
-
-2
-00:00:05,000 --> 00:00:08,000
-Valid subtitle`;
-
-    const expectedOutput = 
-`WEBVTT
-
-2
-00:00:05.000 --> 00:00:08.000
-Valid subtitle
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should convert comma to dot in timestamps', t => {
-    const srtInput = 
-`1
-00:00:01,500 --> 00:00:04,750
-Test subtitle`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:01.500 --> 00:00:04.750
-Test subtitle
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle extra whitespace in input', t => {
-    const srtInput = `
-
-1   
-  00:00:01,000 --> 00:00:04,000  
-  Hello world  
-
-`;
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:01.000 --> 00:00:04.000
-Hello world
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle timestamps with only minutes and seconds', t => {
-    const srtInput = 
-`1
-01:30,000 --> 02:45,500
-Short timestamp format`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:01:30.000 --> 00:02:45.500
-Short timestamp format
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle ultra-short timestamps (SS.mmm)', t => {
-    const srtInput = 
-`1
-03.298 --> 04.578
-First line
-
-2
-04.578 --> 06.178
-Second line`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:03.298 --> 00:00:04.578
-First line
-
-2
-00:00:04.578 --> 00:00:06.178
-Second line
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});
-
-test('should handle mixed timestamp formats', t => {
-    const srtInput = 
-`1
-03.298 --> 04.578
-First line
-
-2
-00:04.578 --> 00:06.178
-Second line
-
-3
-00:00:06.178 --> 00:00:07.518
-Third line`;
-
-    const expectedOutput = 
-`WEBVTT
-
-1
-00:00:03.298 --> 00:00:04.578
-First line
-
-2
-00:00:04.578 --> 00:00:06.178
-Second line
-
-3
-00:00:06.178 --> 00:00:07.518
-Third line
-
-`;
-    t.is(convertSrtToVtt(srtInput), expectedOutput);
-});