@aj-archipelago/cortex 1.4.6 → 1.4.7

package/pathways/system/entity/tools/sys_tool_validate_url.js

@@ -0,0 +1,137 @@
+// sys_tool_validate_url.js
+// Tool pathway that validates URLs by performing HEAD requests to check if they are accessible
+import logger from '../../../../lib/logger.js';
+
+export default {
+    prompt: [],
+    timeout: 30,
+    toolDefinition: { 
+        type: "function",
+        icon: "🔗",
+        function: {
+            name: "ValidateUrl",
+            description: "This tool validates URLs by performing a HEAD request to check if they are accessible and return valid responses. Use this to verify that links and image URLs are valid before including them in responses.",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "The URL to validate (can be a link or image URL)"
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["url", "userMessage"]
+            }
+        }
+    },
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        const { url } = args;
+        
+        if (!url || typeof url !== 'string') {
+            throw new Error("URL parameter is required and must be a string");
+        }
+
+        // Basic URL format validation
+        try {
+            new URL(url);
+        } catch (e) {
+            return JSON.stringify({
+                valid: false,
+                error: "Invalid URL format",
+                url: url,
+                statusCode: null,
+                contentType: null
+            });
+        }
+
+        try {
+            // Perform HEAD request to validate the URL
+            // Use a timeout to avoid hanging on slow/unresponsive servers
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 2000); // 2 second timeout for HEAD
+
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: 'HEAD',
+                    signal: controller.signal,
+                    redirect: 'follow',
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (compatible; Cortex/1.0)'
+                    }
+                });
+                clearTimeout(timeoutId);
+            } catch (fetchError) {
+                clearTimeout(timeoutId);
+                
+                // If HEAD fails, try GET with range request (more compatible)
+                if (fetchError.name === 'AbortError') {
+                    throw new Error("Request timeout - URL did not respond in time");
+                }
+                
+                // Some servers don't support HEAD, try GET with range
+                try {
+                    const getController = new AbortController();
+                    const getTimeoutId = setTimeout(() => getController.abort(), 25000);
+                    
+                    response = await fetch(url, {
+                        method: 'GET',
+                        signal: getController.signal,
+                        redirect: 'follow',
+                        headers: {
+                            'User-Agent': 'Mozilla/5.0 (compatible; Cortex/1.0)',
+                            'Range': 'bytes=0-0' // Only request first byte to minimize data transfer
+                        }
+                    });
+                    clearTimeout(getTimeoutId);
+                } catch (getError) {
+                    if (getError.name === 'AbortError') {
+                        throw new Error("Request timeout - URL did not respond in time");
+                    }
+                    throw getError;
+                }
+            }
+
+            const statusCode = response.status;
+            const contentType = response.headers.get('content-type') || '';
+            const contentLength = response.headers.get('content-length');
+            const finalUrl = response.url || url; // Get final URL after redirects
+
+            // Consider 2xx and 3xx status codes as valid
+            const isValid = statusCode >= 200 && statusCode < 400;
+
+            const result = {
+                valid: isValid,
+                url: finalUrl,
+                statusCode: statusCode,
+                contentType: contentType,
+                contentLength: contentLength ? parseInt(contentLength, 10) : null,
+                message: isValid 
+                    ? `URL is valid and accessible (HTTP ${statusCode})`
+                    : `URL returned error status (HTTP ${statusCode})`
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: "ValidateUrl" });
+            return JSON.stringify(result);
+
+        } catch (e) {
+            logger.error(`Error validating URL ${url}: ${e.message}`);
+            
+            const errorResult = {
+                valid: false,
+                url: url,
+                statusCode: null,
+                contentType: null,
+                error: e.message || "Unknown error occurred while validating URL"
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: "ValidateUrl" });
+            return JSON.stringify(errorResult);
+        }
+    }
+};
+

package/pathways/system/entity/tools/sys_tool_writefile.js

@@ -0,0 +1,211 @@
+// sys_tool_writefile.js
+// Entity tool that writes content to a file and uploads it to cloud storage
+import logger from '../../../../lib/logger.js';
+import { uploadFileToCloud, addFileToCollection, getMimeTypeFromFilename } from '../../../../lib/fileUtils.js';
+
+// Helper function to format file size
+function formatFileSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+export default {
+    prompt: [],
+    timeout: 60,
+    toolDefinition: { 
+        type: "function",
+        icon: "✍️",
+        function: {
+            name: "WriteFile",
+            description: "Write content to a file and upload it to cloud storage. The file will be added to your file collection for future reference. Use this to save text, code, data, or any content you generate to a file.",
+            parameters: {
+                type: "object",
+                properties: {
+                    content: {
+                        type: "string",
+                        description: "The content to write to the file"
+                    },
+                    filename: {
+                        type: "string",
+                        description: "The filename for the file (e.g., 'output.txt', 'data.json', 'script.py'). Include the file extension."
+                    },
+                    tags: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        },
+                        description: "Optional: Array of tags to categorize the file (e.g., ['code', 'output', 'data'])"
+                    },
+                    notes: {
+                        type: "string",
+                        description: "Optional: Notes or description about the file"
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["content", "filename", "userMessage"]
+            }
+        }
+    },
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        const { content, filename, tags = [], notes = '', contextId, contextKey } = args;
+        
+        // Validate inputs and return JSON error if invalid
+        if (content === undefined || content === null) {
+            const errorResult = {
+                success: false,
+                filename: filename || 'unknown',
+                error: "content is required and cannot be null or undefined"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        if (typeof content !== 'string') {
+            const errorResult = {
+                success: false,
+                filename: filename || 'unknown',
+                error: `content must be a string, got ${typeof content}`
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        if (!filename || typeof filename !== 'string') {
+            const errorResult = {
+                success: false,
+                filename: 'unknown',
+                error: "filename is required and must be a non-empty string"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        // Validate filename doesn't contain invalid characters
+        if (filename.trim().length === 0) {
+            const errorResult = {
+                success: false,
+                filename: filename,
+                error: "filename cannot be empty or whitespace only"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        // Validate tags if provided
+        if (tags !== undefined && !Array.isArray(tags)) {
+            const errorResult = {
+                success: false,
+                filename: filename,
+                error: "tags must be an array if provided"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        // Validate notes if provided
+        if (notes !== undefined && typeof notes !== 'string') {
+            const errorResult = {
+                success: false,
+                filename: filename,
+                error: "notes must be a string if provided"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+
+        try {
+            // Convert content to buffer
+            const fileBuffer = Buffer.from(content, 'utf8');
+            logger.info(`Prepared content buffer for file: ${filename} (${fileBuffer.length} bytes)`);
+
+            // Determine MIME type from filename using utility function
+            let mimeType = getMimeTypeFromFilename(filename, 'text/plain');
+            
+            // Add charset=utf-8 for text-based MIME types to ensure proper encoding
+            if (mimeType.startsWith('text/') || mimeType === 'application/json' || 
+                mimeType === 'application/javascript' || mimeType === 'application/typescript' ||
+                mimeType === 'application/xml') {
+                mimeType = `${mimeType}; charset=utf-8`;
+            }
+
+            // Upload file to cloud storage (this will compute hash and check for duplicates)
+            const uploadResult = await uploadFileToCloud(
+                fileBuffer,
+                mimeType,
+                filename,
+                resolver
+            );
+
+            if (!uploadResult || !uploadResult.url) {
+                throw new Error('Failed to upload file to cloud storage');
+            }
+
+            // Add to file collection if contextId is provided
+            let fileEntry = null;
+            if (contextId) {
+                try {
+                    fileEntry = await addFileToCollection(
+                        contextId,
+                        contextKey || null,
+                        uploadResult.url,
+                        uploadResult.gcs || null,
+                        filename,
+                        tags,
+                        notes,
+                        uploadResult.hash || null,
+                        null, // fileUrl - not needed since we already uploaded
+                        resolver
+                    );
+                } catch (collectionError) {
+                    // Log but don't fail - file collection is optional
+                    logger.warn(`Failed to add file to collection: ${collectionError.message}`);
+                }
+            }
+
+            const fileSize = Buffer.byteLength(content, 'utf8');
+            const result = {
+                success: true,
+                filename: filename,
+                url: uploadResult.url,
+                gcs: uploadResult.gcs || null,
+                hash: uploadResult.hash || null,
+                fileId: fileEntry?.id || null,
+                size: fileSize,
+                sizeFormatted: formatFileSize(fileSize),
+                message: `File "${filename}" written and uploaded successfully (${formatFileSize(fileSize)})`
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(result);
+
+        } catch (error) {
+            let errorMsg;
+            if (error?.message) {
+                errorMsg = error.message;
+            } else if (error?.errors && Array.isArray(error.errors)) {
+                // Handle AggregateError
+                errorMsg = error.errors.map(e => e?.message || String(e)).join('; ');
+            } else {
+                errorMsg = String(error);
+            }
+            logger.error(`Error writing file ${filename}: ${errorMsg}`);
+            
+            const errorResult = {
+                success: false,
+                filename: filename,
+                error: errorMsg
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: "WriteFile" });
+            return JSON.stringify(errorResult);
+        }
+    }
+};
+

package/pathways/system/workspaces/run_workspace_prompt.js

@@ -1,5 +1,6 @@
 import { config } from '../../../config.js';
-import { chatArgsHasImageUrl, chatArgsHasType, getAvailableFiles, removeOldImageAndFileContent } from '../../../lib/util.js';
+import { chatArgsHasImageUrl, chatArgsHasType, removeOldImageAndFileContent } from '../../../lib/util.js';
+import { getAvailableFiles } from '../../../lib/fileUtils.js';
 import { loadEntityConfig } from '../../../pathways/system/entity/tools/shared/sys_entity_tools.js';
 import { Prompt } from '../../../server/prompt.js';
 
@@ -48,8 +49,8 @@ export default {
             model
         };
 
-        // Extract available files from chat history
-        const availableFiles = getAvailableFiles(args.chatHistory);
+        // Extract available files from chat history (syncs to collection if contextId available)
+        const availableFiles = await getAvailableFiles(args.chatHistory, args.contextId, args.contextKey);
 
         // Check for both image and file content (CSV files have type 'file', not 'image_url')
         const hasImageContent = chatArgsHasImageUrl(args);

package/pathways/transcribe_gemini.js

@@ -1,6 +1,7 @@
 import logger from "../lib/logger.js";
 import { publishRequestProgress } from "../lib/redisSubscription.js";
-import { alignSubtitles, getMediaChunks } from "../lib/util.js";
+import { alignSubtitles } from "../lib/util.js";
+import { getMediaChunks } from "../lib/fileUtils.js";
 import { Prompt } from "../server/prompt.js";
 
 const OFFSET_CHUNK = 500; //seconds of each chunk offset, only used if helper does not provide

package/server/executeWorkspace.js

@@ -24,7 +24,7 @@ const resolveAndAddFileContent = async (pathways, pathwayArgs, requestId, config
     for (const pathway of pathwaysWithFiles) {
         if (pathway.fileHashes && pathway.fileHashes.length > 0) {
             try {
-                const { resolveFileHashesToContent } = await import('../lib/util.js');
+                const { resolveFileHashesToContent } = await import('../lib/fileUtils.js');
                 const fileContent = await resolveFileHashesToContent(pathway.fileHashes, config);
                 
                 // Add file content to chatHistory if not already present (only do this once)

package/server/plugins/neuralSpacePlugin.js

@@ -2,12 +2,8 @@ import ModelPlugin from "./modelPlugin.js";
 import fs from "fs";
 import FormData from "form-data";
 import logger from "../../lib/logger.js";
-import {
-  alignSubtitles,
-  deleteTempPath,
-  downloadFile,
-  getMediaChunks,
-} from "../../lib/util.js";
+import { alignSubtitles } from "../../lib/util.js";
+import { deleteTempPath, downloadFile, getMediaChunks } from "../../lib/fileUtils.js";
 import CortexRequest from "../../lib/cortexRequest.js";
 import { publishRequestProgress } from "../../lib/redisSubscription.js";
 

package/server/plugins/openAiWhisperPlugin.js

@@ -6,7 +6,8 @@ import fs from 'fs';
 import { publishRequestProgress } from '../../lib/redisSubscription.js';
 import logger from '../../lib/logger.js';
 import CortexRequest from '../../lib/cortexRequest.js';
-import { downloadFile, deleteTempPath, convertSrtToText, alignSubtitles, getMediaChunks, markCompletedForCleanUp  } from '../../lib/util.js';
+import { convertSrtToText, alignSubtitles } from '../../lib/util.js';
+import { downloadFile, deleteTempPath, getMediaChunks, markCompletedForCleanUp } from '../../lib/fileUtils.js';
 
 
 const OFFSET_CHUNK = 500; //seconds of each chunk offset, only used if helper does not provide

package/server/plugins/replicateApiPlugin.js

@@ -3,6 +3,7 @@ import ModelPlugin from "./modelPlugin.js";
 import CortexResponse from "../../lib/cortexResponse.js";
 import logger from "../../lib/logger.js";
 import axios from "axios";
+import mime from "mime-types";
 
 class ReplicateApiPlugin extends ModelPlugin {
   constructor(pathway, model) {
@@ -475,20 +476,9 @@ class ReplicateApiPlugin extends ModelPlugin {
 
   // Helper method to determine MIME type from URL extension
   getMimeTypeFromUrl(url) {
-    const extension = url.split('.').pop().toLowerCase();
-    switch (extension) {
-      case 'jpg':
-      case 'jpeg':
-        return 'image/jpeg';
-      case 'png':
-        return 'image/png';
-      case 'gif':
-        return 'image/gif';
-      case 'webp':
-        return 'image/webp';
-      default:
-        return 'image/jpeg'; // Default fallback
-    }
+    // Extract path from URL (remove query params and fragments)
+    const urlPath = url.split('?')[0].split('#')[0];
+    return mime.lookup(urlPath) || 'image/jpeg'; // Default fallback for images
   }
 
   // Override the logging function to display the request and response

package/server/typeDef.js

@@ -90,6 +90,10 @@ const getGraphQlType = (value) => {
       // Check if it's an integer or float
       return Number.isInteger(value) ? {type: 'Int', defaultValue: value} : {type: 'Float', defaultValue: value};
     case 'object':
+      // Handle null explicitly (typeof null === 'object' in JavaScript)
+      if (value === null) {
+        return {type: 'String', defaultValue: '""'};
+      }
       if (Array.isArray(value)) {
         if (value.length > 0 && typeof(value[0]) === 'string') {
           return {type: '[String]', defaultValue: JSON.stringify(value)};
@@ -104,7 +108,12 @@ const getGraphQlType = (value) => {
           }
         }
       } else {
-        return {type: `[${value.objName}]`, defaultValue: JSON.stringify(value)};
+        // Check if it has objName property (for custom object types)
+        if (value && value.objName) {
+          return {type: `[${value.objName}]`, defaultValue: JSON.stringify(value)};
+        }
+        // Otherwise treat as generic object (stringify it)
+        return {type: 'String', defaultValue: `"${JSON.stringify(value).replace(/"/g, '\\"')}"`};
       }
     default:
       return {type: 'String', defaultValue: `"${value}"`};