@aj-archipelago/cortex 0.0.6 → 0.0.8

package/graphql/pathwayResolver.js

@@ -12,15 +12,16 @@ const { requestState } = require('./requestState');
 
 const MAX_PREVIOUS_RESULT_TOKEN_LENGTH = 1000;
 
-const callPathway = async (config, pathwayName, requestState, { text, ...parameters }) => {
-    const pathwayResolver = new PathwayResolver({ config, pathway: config.get(`pathways.${pathwayName}`), requestState });
+const callPathway = async (config, pathwayName, args, requestState, { text, ...parameters }) => {
+    const pathwayResolver = new PathwayResolver({ config, pathway: config.get(`pathways.${pathwayName}`), args, requestState });
     return await pathwayResolver.resolve({ text, ...parameters });
 }
 
 class PathwayResolver {
-    constructor({ config, pathway }) {
+    constructor({ config, pathway, args }) {
         this.config = config;
         this.pathway = pathway;
+        this.args = args;
         this.useInputChunking = pathway.useInputChunking;
         this.chunkMaxTokenLength = 0;
         this.warnings = [];
@@ -29,22 +30,21 @@ class PathwayResolver {
         this.pathwayPrompter = new PathwayPrompter({ config, pathway });
         this.previousResult = '';
         this.prompts = [];
-        this._pathwayPrompt = '';
 
         Object.defineProperty(this, 'pathwayPrompt', {
             get() {
-                return this._pathwayPrompt;
+                return this.prompts
             },
             set(value) {
-                this._pathwayPrompt = value;
-                if (!Array.isArray(this._pathwayPrompt)) {
-                    this._pathwayPrompt = [this._pathwayPrompt];
+                if (!Array.isArray(value)) {
+                    value = [value];
                 }
-                this.prompts = this._pathwayPrompt.map(p => (p instanceof Prompt) ? p : new Prompt({ prompt:p }));
+                this.prompts = value.map(p => (p instanceof Prompt) ? p : new Prompt({ prompt:p }));
                 this.chunkMaxTokenLength = this.getChunkMaxTokenLength();
             }
         });
 
+        // set up initial prompt
         this.pathwayPrompt = pathway.prompt;
     }
 
@@ -145,25 +145,25 @@ class PathwayResolver {
 
     // Here we choose how to handle long input - either summarize or chunk
     processInputText(text) {
-        let chunkMaxChunkTokenLength = 0;
+        let chunkTokenLength = 0;
         if (this.pathway.inputChunkSize) {
-            chunkMaxChunkTokenLength = Math.min(this.pathway.inputChunkSize, this.chunkMaxTokenLength);
+            chunkTokenLength = Math.min(this.pathway.inputChunkSize, this.chunkMaxTokenLength);
         } else {
-            chunkMaxChunkTokenLength = this.chunkMaxTokenLength;
+            chunkTokenLength = this.chunkMaxTokenLength;
         }
         const encoded = encode(text);
-        if (!this.useInputChunking || encoded.length <= chunkMaxChunkTokenLength) { // no chunking, return as is
-            if (encoded.length >= chunkMaxChunkTokenLength) {
-                const warnText = `Your input is possibly too long, truncating! Text length: ${text.length}`;
+        if (!this.useInputChunking || encoded.length <= chunkTokenLength) { // no chunking, return as is
+            if (encoded.length >= chunkTokenLength) {
+                const warnText = `Truncating long input text. Text length: ${text.length}`;
                 this.warnings.push(warnText);
                 console.warn(warnText);
-                text = this.truncate(text, chunkMaxChunkTokenLength);
+                text = this.truncate(text, chunkTokenLength);
             }
             return [text];
         }
 
         // chunk the text and return the chunks with newline separators
-        return getSemanticChunks({ text, maxChunkToken: chunkMaxChunkTokenLength });
+        return getSemanticChunks({ text, maxChunkToken: chunkTokenLength });
     }
 
     truncate(str, n) {
@@ -175,7 +175,7 @@ class PathwayResolver {
 
     async summarizeIfEnabled({ text, ...parameters }) {
         if (this.pathway.useInputSummarization) {
-            return await callPathway(this.config, 'summary', requestState, { text, targetLength: 1000, ...parameters });
+            return await callPathway(this.config, 'summary', this.args, requestState, { text, targetLength: 1000, ...parameters });
         }
         return text;
     }
@@ -183,30 +183,21 @@ class PathwayResolver {
     // Calculate the maximum token length for a chunk
     getChunkMaxTokenLength() {
         // find the longest prompt
-        const maxPromptTokenLength = Math.max(...this.prompts.map(({ prompt }) => prompt ? encode(String(prompt)).length : 0));
-        const maxMessagesTokenLength = Math.max(...this.prompts.map(({ messages }) => messages ? messages.reduce((acc, {role, content}) => {
-            return (role && content) ? acc + encode(role).length + encode(content).length : acc;
-        }, 0) : 0));
-
-        const maxTokenLength = Math.max(maxPromptTokenLength, maxMessagesTokenLength);
-
+        const maxPromptTokenLength = Math.max(...this.prompts.map((promptData) => this.pathwayPrompter.plugin.getCompiledPrompt('', this.args, promptData).tokenLength));
+        
         // find out if any prompts use both text input and previous result
-        const hasBothProperties = this.prompts.some(prompt => prompt.usesInputText && prompt.usesPreviousResult);
+        const hasBothProperties = this.prompts.some(prompt => prompt.usesTextInput && prompt.usesPreviousResult);
         
         // the token ratio is the ratio of the total prompt to the result text - both have to be included
         // in computing the max token length
         const promptRatio = this.pathwayPrompter.plugin.getPromptTokenRatio();
-        let maxChunkToken = promptRatio * this.pathwayPrompter.plugin.getModelMaxTokenLength() - maxTokenLength;
-
+        let chunkMaxTokenLength = promptRatio * this.pathwayPrompter.plugin.getModelMaxTokenLength() - maxPromptTokenLength;
+        
         // if we have to deal with prompts that have both text input
         // and previous result, we need to split the maxChunkToken in half
-        maxChunkToken = hasBothProperties ? maxChunkToken / 2 : maxChunkToken;
-
-        // detect if the longest prompt might be too long to allow any chunk size
-        if (maxChunkToken && maxChunkToken <= 0) {
-            throw new Error(`Your prompt is too long! Split to multiple prompts or reduce length of your prompt, prompt length: ${maxPromptLength}`);
-        }
-        return maxChunkToken;
+        chunkMaxTokenLength = hasBothProperties ? chunkMaxTokenLength / 2 : chunkMaxTokenLength;
+        
+        return chunkMaxTokenLength;
     }
 
     // Process the request and return the result        
@@ -300,7 +291,7 @@ class PathwayResolver {
         if (requestState[this.requestId].canceled) {
             return;
         }
-        const result = await this.pathwayPrompter.execute(text, { ...parameters, ...this.savedContext }, prompt);
+        const result = await this.pathwayPrompter.execute(text, { ...parameters, ...this.savedContext }, prompt, this);
         requestState[this.requestId].completedCount++;
 
         const { completedCount, totalCount } = requestState[this.requestId];

package/graphql/plugins/azureTranslatePlugin.js

@@ -1,19 +1,16 @@
 // AzureTranslatePlugin.js
 const ModelPlugin = require('./modelPlugin');
-const handlebars = require("handlebars");
 
 class AzureTranslatePlugin extends ModelPlugin {
-    constructor(config, modelName, pathway) {
-        super(config, modelName, pathway);
+    constructor(config, pathway) {
+        super(config, pathway);
     }
-
+    
     // Set up parameters specific to the Azure Translate API
-    requestParameters(text, parameters, prompt) {
+    getRequestParameters(text, parameters, prompt) {
         const combinedParameters = { ...this.promptParameters, ...parameters };
-        const modelPrompt = this.getModelPrompt(prompt, parameters);
-        const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
-
-        return {
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+        const requestParameters = {
             data: [
                 {
                 Text: modelPromptText,
@@ -23,11 +20,12 @@ class AzureTranslatePlugin extends ModelPlugin {
                 to: combinedParameters.to
             }
         };
+        return requestParameters;
     }
 
     // Execute the request to the Azure Translate API
     async execute(text, parameters, prompt) {
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
 
         const url = this.requestUrl(text);
 
@@ -35,7 +33,7 @@ class AzureTranslatePlugin extends ModelPlugin {
         const params = requestParameters.params;
         const headers = this.model.headers || {};
 
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/modelPlugin.js

@@ -38,6 +38,55 @@ class ModelPlugin {
         this.shouldCache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
     }
 
+    // Function to remove non-system messages until token length is less than target
+    removeMessagesUntilTarget = (messages, targetTokenLength) => {
+        let chatML = this.messagesToChatML(messages);
+        let tokenLength = encode(chatML).length;
+    
+        while (tokenLength > targetTokenLength) {
+            for (let i = 0; i < messages.length; i++) {
+                if (messages[i].role !== 'system') {
+                    messages.splice(i, 1);
+                    chatML = this.messagesToChatML(messages);
+                    tokenLength = encode(chatML).length;
+                    break;
+                }
+            }
+            if (messages.every(message => message.role === 'system')) {
+                break; // All remaining messages are 'system', stop removing messages
+            }
+        }
+        return messages;
+    }
+
+    //convert a messages array to a simple chatML format
+    messagesToChatML = (messages) => {
+        let output = "";
+        if (messages && messages.length) {
+            for (let message of messages) {
+                output += (message.role && message.content) ? `<|im_start|>${message.role}\n${message.content}\n<|im_end|>\n` : `${message}\n`;
+            }
+            // you always want the assistant to respond next so add a
+            // directive for that
+            output += "<|im_start|>assistant\n";
+        }
+        return output;
+    }
+
+    getCompiledPrompt(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const modelPrompt = this.getModelPrompt(prompt, parameters);
+        const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
+        const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
+        const modelPromptMessagesML = this.messagesToChatML(modelPromptMessages);
+
+        if (modelPromptMessagesML) {
+            return { modelPromptMessages, tokenLength: encode(modelPromptMessagesML).length };
+        } else {
+            return { modelPromptText, tokenLength: encode(modelPromptText).length };
+        }
+    }
+
     getModelMaxTokenLength() {
         return (this.promptParameters.maxTokenLength ?? this.model.maxTokenLength ?? DEFAULT_MAX_TOKENS);
     }
@@ -120,40 +169,37 @@ class ModelPlugin {
         return messageResult ?? textResult ?? null;
     }
 
-    logMessagePreview(messages) {
-        messages.forEach((message, index) => {
-            const words = message.content.split(" ");
-            const tokenCount = encode(message.content).length;
-            let preview;
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
     
-            if (index === 0) {
-                preview = message.content;
-            } else {
-                preview = words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
-            }
+        const modelInput = data.prompt || (data.messages && data.messages[0].content) || (data.length > 0 && data[0].Text) || null;
     
-            console.log(`Message ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"`);
-        });
-    }
+        if (data && data.messages && data.messages.length > 1) {
+            data.messages.forEach((message, index) => {
+                const words = message.content.split(" ");
+                const tokenCount = encode(message.content).length;
+                const preview = words.length < 41 ? message.content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
     
-    async executeRequest(url, data, params, headers) {
-        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
-        const modelInput = data.prompt || (data.messages && data.messages[0].content) || data[0].Text || null;
-        
-        console.log(`=== ${this.pathwayName}.${this.requestCount++} ===`);
-        
-        if (data.messages && data.messages.length > 1) {
-            this.logMessagePreview(data.messages);
+                console.log(`\x1b[36mMessage ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+            });
         } else {
             console.log(`\x1b[36m${modelInput}\x1b[0m`);
         }
-        
+    
         console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
     
+        prompt && prompt.debugInfo && (prompt.debugInfo += `${separator}${JSON.stringify(data)}`);
+    }
+    
+    async executeRequest(url, data, params, headers, prompt) {
+        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
+        
         if (responseData.error) {
             throw new Exception(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
         }
     
+        this.logRequestData(data, responseData, prompt);
         return this.parseResponse(responseData);
     }
 

package/graphql/plugins/openAiChatPlugin.js

@@ -1,6 +1,5 @@
 // OpenAIChatPlugin.js
 const ModelPlugin = require('./modelPlugin');
-const handlebars = require("handlebars");
 
 class OpenAIChatPlugin extends ModelPlugin {
     constructor(config, pathway) {
@@ -8,30 +7,39 @@ class OpenAIChatPlugin extends ModelPlugin {
     }
 
     // Set up parameters specific to the OpenAI Chat API
-    requestParameters(text, parameters, prompt) {
-        const combinedParameters = { ...this.promptParameters, ...parameters };
-        const modelPrompt = this.getModelPrompt(prompt, parameters);
-        const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
-        const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
-
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, modelPromptMessages, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
         const { stream } = parameters;
-
-        return {
-            messages: modelPromptMessages || [{ "role": "user", "content": modelPromptText }],
-            temperature: this.temperature ?? 0.7,
-            stream
+    
+        // Define the model's max token length
+        const modelMaxTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        let requestMessages = modelPromptMessages || [{ "role": "user", "content": modelPromptText }];
+    
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelMaxTokenLength) {
+            // Remove older messages until the token length is within the model's limit
+            requestMessages = this.removeMessagesUntilTarget(requestMessages, modelMaxTokenLength);
+        }
+    
+        const requestParameters = {
+        messages: requestMessages,
+        temperature: this.temperature ?? 0.7,
+        stream
         };
+    
+        return requestParameters;
     }
 
     // Execute the request to the OpenAI Chat API
     async execute(text, parameters, prompt) {
         const url = this.requestUrl(text);
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
 
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/openAiCompletionPlugin.js

@@ -1,67 +1,68 @@
 // OpenAICompletionPlugin.js
 const ModelPlugin = require('./modelPlugin');
-const handlebars = require("handlebars");
 const { encode } = require("gpt-3-encoder");
 
-//convert a messages array to a simple chatML format
-const messagesToChatML = (messages) => {
-    let output = "";
-    if (messages && messages.length) {
-        for (let message of messages) {
-            output += (message.role && message.content) ? `<|im_start|>${message.role}\n${message.content}\n<|im_end|>\n` : `${message}\n`;
-        }
-        // you always want the assistant to respond next so add a
-        // directive for that
-        output += "<|im_start|>assistant\n";
-    }
-    return output;
-}
-
 class OpenAICompletionPlugin extends ModelPlugin {
     constructor(config, pathway) {
         super(config, pathway);
     }
 
     // Set up parameters specific to the OpenAI Completion API
-    requestParameters(text, parameters, prompt) {
-        const combinedParameters = { ...this.promptParameters, ...parameters };
-        const modelPrompt = this.getModelPrompt(prompt, parameters);
-        const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
-        const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
-        const modelPromptMessagesML = messagesToChatML(modelPromptMessages);
-
+    getRequestParameters(text, parameters, prompt) {
+        let { modelPromptMessages, modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
         const { stream } = parameters;
-
-        if (modelPromptMessagesML) {
-        return {
-            prompt: modelPromptMessagesML,
-            max_tokens: this.getModelMaxTokenLength() - encode(modelPromptMessagesML).length - 1,
-            temperature: this.temperature ?? 0.7,
-            top_p: 0.95,
-            frequency_penalty: 0,
-            presence_penalty: 0,
-            stop: ["<|im_end|>"],
-            stream
-        };
+        let modelPromptMessagesML = '';
+        const modelMaxTokenLength = this.getModelMaxTokenLength();
+        let requestParameters = {};
+    
+        if (modelPromptMessages) {
+            const requestMessages = this.removeMessagesUntilTarget(modelPromptMessages, modelMaxTokenLength - 1);
+            modelPromptMessagesML = this.messagesToChatML(requestMessages);
+            tokenLength = encode(modelPromptMessagesML).length;
+        
+            if (tokenLength >= modelMaxTokenLength) {
+                throw new Error(`The maximum number of tokens for this model is ${modelMaxTokenLength}. Please reduce the number of messages in the prompt.`);
+            }
+        
+            const max_tokens = modelMaxTokenLength - tokenLength - 1;
+        
+            requestParameters = {
+                prompt: modelPromptMessagesML,
+                max_tokens: max_tokens,
+                temperature: this.temperature ?? 0.7,
+                top_p: 0.95,
+                frequency_penalty: 0,
+                presence_penalty: 0,
+                stop: ["<|im_end|>"],
+                stream
+            };
         } else {
-        return {
-            prompt: modelPromptText,
-            max_tokens: this.getModelMaxTokenLength() - encode(modelPromptText).length - 1,
-            temperature: this.temperature ?? 0.7,
-            stream
-        };
+            if (tokenLength >= modelMaxTokenLength) {
+                throw new Error(`The maximum number of tokens for this model is ${modelMaxTokenLength}. Please reduce the length of the prompt.`);
+            }
+        
+            const max_tokens = modelMaxTokenLength - tokenLength - 1;
+        
+            requestParameters = {
+                prompt: modelPromptText,
+                max_tokens: max_tokens,
+                temperature: this.temperature ?? 0.7,
+                stream
+            };
         }
+    
+        return requestParameters;
     }
 
     // Execute the request to the OpenAI Completion API
     async execute(text, parameters, prompt) {
         const url = this.requestUrl(text);
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
     
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/openAiWhisperPlugin.js

@@ -0,0 +1,91 @@
+// OpenAICompletionPlugin.js
+const ModelPlugin = require('./modelPlugin');
+const FormData = require('form-data');
+const fs = require('fs');
+const { splitMediaFile, isValidYoutubeUrl, processYoutubeUrl, deleteTempPath } = require('../../lib/fileChunker');
+const pubsub = require('../pubsub');
+
+class OpenAIWhisperPlugin extends ModelPlugin {
+    constructor(config, pathway) {
+        super(config, pathway);
+    }
+
+    // Execute the request to the OpenAI Whisper API
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const url = this.requestUrl(text);
+        const params = {};
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+
+        const processChunk = async (chunk) => {
+            try {
+                const formData = new FormData();
+                formData.append('file', fs.createReadStream(chunk));
+                formData.append('model', this.model.params.model);
+                formData.append('response_format', 'text');
+                // formData.append('language', 'tr');
+                modelPromptText && formData.append('prompt', modelPromptText);
+
+                return this.executeRequest(url, formData, params, { ...this.model.headers, ...formData.getHeaders() });
+            } catch (err) {
+                console.log(err);
+            }
+        }
+
+        let result = ``;
+        let { file } = parameters;
+        let folder;
+        const isYoutubeUrl = isValidYoutubeUrl(file);
+        let totalCount = 0;
+        let completedCount = 0;
+        const { requestId } = pathwayResolver;
+
+        const sendProgress = () => {
+            completedCount++;
+            pubsub.publish('REQUEST_PROGRESS', {
+                requestProgress: {
+                    requestId,
+                    progress: completedCount / totalCount,
+                    data: null,
+                }
+            });
+        }
+
+        try {
+            if (isYoutubeUrl) {
+                // totalCount += 1; // extra 1 step for youtube download
+                file = await processYoutubeUrl(file);
+            }
+
+            const { chunkPromises, uniqueOutputPath } = await splitMediaFile(file);
+            folder = uniqueOutputPath;
+            totalCount += chunkPromises.length * 2; // 2 steps for each chunk (download and upload)
+            // isYoutubeUrl && sendProgress(); // send progress for youtube download after total count is calculated
+
+            // sequential download of chunks
+            const chunks = [];
+            for (const chunkPromise of chunkPromises) {
+                sendProgress();
+                chunks.push(await chunkPromise);
+            }
+
+            // sequential processing of chunks
+            for (const chunk of chunks) {
+                result += await processChunk(chunk);
+                sendProgress();
+            }
+
+            // parallel processing, dropped 
+            // result = await Promise.all(mediaSplit.chunks.map(processChunk));
+
+        } catch (error) {
+            console.error("An error occurred:", error);
+        } finally {
+            isYoutubeUrl && (await deleteTempPath(file));
+            folder && (await deleteTempPath(folder));
+        }
+        return result;
+    }
+}
+
+module.exports = OpenAIWhisperPlugin;
+

package/graphql/prompt.js

@@ -12,6 +12,7 @@ class Prompt {
 
         this.usesTextInput = promptContains('text', this.prompt ? this.prompt : this.messages);
         this.usesPreviousResult = promptContains('previousResult', this.prompt ? this.prompt : this.messages);
+        this.debugInfo = '';
     }
 }
 

package/graphql/resolver.js

@@ -12,16 +12,16 @@ const rootResolver = async (parent, args, contextValue, info) => {
         info.cacheControl.setCacheHint({ maxAge: 60 * 60 * 24, scope: 'PUBLIC' });
     }
 
-    const pathwayResolver = new PathwayResolver({ config, pathway, requestState });
+    const pathwayResolver = new PathwayResolver({ config, pathway, args, requestState });
     contextValue.pathwayResolver = pathwayResolver;
 
-    // Add request parameters back as debug
-    const requestParameters = pathwayResolver.prompts.map((prompt) => pathwayResolver.pathwayPrompter.plugin.requestParameters(args.text, args, prompt));
-    const debug = JSON.stringify(requestParameters);
-
     // Execute the request with timeout
     const result = await fulfillWithTimeout(pathway.resolver(parent, args, contextValue, info), pathway.timeout);
     const { warnings, previousResult, savedContextId } = pathwayResolver;
+    
+    // Add request parameters back as debug
+    const debug = pathwayResolver.prompts.map(prompt => prompt.debugInfo || '').join('\n').trim();
+    
     return { debug, result, warnings, previousResult, contextId: savedContextId }
 }