@aj-archipelago/cortex 1.4.32 → 1.4.33

package/config.js

@@ -575,6 +575,72 @@ var config = convict({
                 "maxImageSize": 5242880,
                 "supportsStreaming": true
             },
+            "claude-sonnet-4": {
+                "type": "CLAUDE-ANTHROPIC",
+                "emulateOpenAIChatModel": "claude-sonnet-4",
+                "endpoints": [
+                    {
+                        "name": "Anthropic Claude Sonnet 4",
+                        "url": "https://api.anthropic.com/v1/messages",
+                        "headers": {
+                            "x-api-key": "{{CLAUDE_API_KEY}}",
+                            "Content-Type": "application/json"
+                        },
+                        "params": {
+                            "model": "claude-sonnet-4-20250514"
+                        },
+                        "requestsPerSecond": 10
+                    }
+                ],
+                "maxTokenLength": 200000,
+                "maxReturnTokens": 64000,
+                "maxImageSize": 31457280,
+                "supportsStreaming": true
+            },
+            "claude-45-sonnet": {
+                "type": "CLAUDE-ANTHROPIC",
+                "emulateOpenAIChatModel": "claude-4.5-sonnet",
+                "endpoints": [
+                    {
+                        "name": "Anthropic Claude 4.5 Sonnet",
+                        "url": "https://api.anthropic.com/v1/messages",
+                        "headers": {
+                            "x-api-key": "{{CLAUDE_API_KEY}}",
+                            "Content-Type": "application/json"
+                        },
+                        "params": {
+                            "model": "claude-sonnet-4-5-20250514"
+                        },
+                        "requestsPerSecond": 10
+                    }
+                ],
+                "maxTokenLength": 200000,
+                "maxReturnTokens": 64000,
+                "maxImageSize": 31457280,
+                "supportsStreaming": true
+            },
+            "claude-45-opus": {
+                "type": "CLAUDE-ANTHROPIC",
+                "emulateOpenAIChatModel": "claude-4.5-opus",
+                "endpoints": [
+                    {
+                        "name": "Anthropic Claude 4.5 Opus",
+                        "url": "https://api.anthropic.com/v1/messages",
+                        "headers": {
+                            "x-api-key": "{{CLAUDE_API_KEY}}",
+                            "Content-Type": "application/json"
+                        },
+                        "params": {
+                            "model": "claude-opus-4-5-20250514"
+                        },
+                        "requestsPerSecond": 10
+                    }
+                ],
+                "maxTokenLength": 200000,
+                "maxReturnTokens": 32000,
+                "maxImageSize": 31457280,
+                "supportsStreaming": true
+            },
             "gemini-flash-25-vision": {
                 "type": "GEMINI-1.5-VISION",
                 "emulateOpenAIChatModel": "gemini-flash-25",
@@ -778,6 +844,12 @@ var config = convict({
         env: 'OPENAI_API_KEY',
         sensitive: true
     },
+    claudeApiKey: {
+        format: String,
+        default: null,
+        env: 'CLAUDE_API_KEY',
+        sensitive: true
+    },
     openaiApiUrl: {
         format: String,
         default: 'https://api.openai.com/v1/completions',

package/helper-apps/cortex-file-handler/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:18-alpine
+FROM node:22-alpine
 
 WORKDIR /usr/src/app
 

package/lib/fileUtils.js

@@ -1561,11 +1561,27 @@ async function syncAndStripFilesFromChatHistory(chatHistory, agentContext, chatI
     
     // Build lookup map from contextId to contextKey for updates
     const contextKeyMap = new Map(agentContext.map(ctx => [ctx.contextId, ctx.contextKey || null]));
-    
+
+    // Helper to normalize URLs by stripping query parameters (SAS tokens, etc.)
+    // This allows matching URLs that have different query params but same base path
+    const normalizeUrl = (url) => {
+        if (!url) return null;
+        try {
+            // Handle GCS URLs (gs://) by keeping them as-is (no query params)
+            if (url.startsWith('gs://')) return url;
+            const parsed = new URL(url);
+            return `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+        } catch {
+            // If URL parsing fails, return as-is
+            return url;
+        }
+    };
+
     // Build lookup maps for fast matching and context lookup (use ALL files, not just filtered)
     // This allows us to find files that exist in Redis but don't have inCollection set yet
+    // URLs are normalized (query params stripped) to handle SAS tokens and other transient params
     const collectionByHash = new Map(allFiles.filter(f => f.hash).map(f => [f.hash, f]));
-    const collectionByUrl = new Map(allFiles.filter(f => f.url).map(f => [f.url, f]));
+    const collectionByUrl = new Map(allFiles.filter(f => f.url).map(f => [normalizeUrl(f.url), f]));
     const collectionByGcs = new Map(allFiles.filter(f => f.gcs).map(f => [f.gcs, f]));
 
     // Helper to get file from collection (by hash, URL, or GCS) to find _contextId
@@ -1573,12 +1589,15 @@ async function syncAndStripFilesFromChatHistory(chatHistory, agentContext, chatI
         const fileHash = contentObj.hash;
         const fileUrl = contentObj.url || contentObj.image_url?.url;
         const fileGcs = contentObj.gcs;
-        
+
         if (fileHash && collectionByHash.has(fileHash)) {
             return collectionByHash.get(fileHash);
         }
-        if (fileUrl && collectionByUrl.has(fileUrl)) {
-            return collectionByUrl.get(fileUrl);
+        if (fileUrl) {
+            const normalizedUrl = normalizeUrl(fileUrl);
+            if (normalizedUrl && collectionByUrl.has(normalizedUrl)) {
+                return collectionByUrl.get(normalizedUrl);
+            }
         }
         if (fileGcs && collectionByGcs.has(fileGcs)) {
             return collectionByGcs.get(fileGcs);

package/lib/pathwayManager.js

@@ -31,7 +31,7 @@ class LocalStorage extends StorageStrategy {
       const data = await fs.promises.readFile(this.filePath, 'utf8');
       return JSON.parse(data);
     } catch (error) {
-      logger.error(`Error loading pathways from ${this.filePath}:`, error);
+      logger.error(`Error loading pathways from ${this.filePath}: ${error.message}`);
       throw error;
     }
   }
@@ -88,7 +88,7 @@ class AzureBlobStorage extends StorageStrategy {
       logger.info(`Loaded pathways from Azure Blob Storage. ${Object.keys(parsedData).map(user => `${user}(${Object.keys(parsedData[user])})`).join(', ')}`);
       return parsedData;
     } catch (error) {
-      logger.error('Error loading pathways from Azure Blob Storage:', error);
+      logger.error(`Error loading pathways from Azure Blob Storage: ${error.message}`);
       throw error;
     }
   }
@@ -99,7 +99,7 @@ class AzureBlobStorage extends StorageStrategy {
       const content = JSON.stringify(data, null, 2);
       await blockBlobClient.upload(content, content.length);
     } catch (error) {
-      logger.error('Error saving pathways to Azure Blob Storage:', error);
+      logger.error(`Error saving pathways to Azure Blob Storage: ${error.message}`);
     }
   }
 
@@ -155,7 +155,7 @@ class S3Storage extends StorageStrategy {
       const dataString = await streamToString(readableStream);
       return JSON.parse(dataString);
     } catch (error) {
-      logger.error('Error loading pathways from S3:', error);
+      logger.error(`Error loading pathways from S3: ${error.message}`);
       throw error;
     }
   }
@@ -170,7 +170,7 @@ class S3Storage extends StorageStrategy {
       };
       await this.s3.putObject(params);
     } catch (error) {
-      logger.error('Error saving pathways to S3:', error);
+      logger.error(`Error saving pathways to S3: ${error.message}`);
     }
   }
 
@@ -544,7 +544,7 @@ class PathwayManager {
 
       return this.pathways;
     } catch (error) {
-      logger.error('Error in getLatestPathways:', error);
+      logger.error(`Error in getLatestPathways: ${error.message}`);
       throw error;
     }
   }

package/lib/pathwayTools.js

@@ -427,4 +427,24 @@ const sendToolFinish = async (requestId, toolCallId, success, error = null) => {
     }
 };
 
-export { callPathway, gpt3Encode, gpt3Decode, say, callTool, addCitationsToResolver, sendToolStart, sendToolFinish };
+/**
+ * Wrap a promise with a timeout
+ * @param {Promise} promise - The promise to wrap
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @param {string} errorMessage - Error message if timeout occurs
+ * @returns {Promise} - The original promise or rejection on timeout
+ */
+const withTimeout = (promise, timeoutMs, errorMessage = 'Operation timed out') => {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new Error(errorMessage));
+        }, timeoutMs);
+    });
+    
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        clearTimeout(timeoutId);
+    });
+};
+
+export { callPathway, gpt3Encode, gpt3Decode, say, callTool, addCitationsToResolver, sendToolStart, sendToolFinish, withTimeout };

package/lib/requestExecutor.js

@@ -101,7 +101,16 @@ const createLimiter = (endpoint, name, index) => {
             logger.debug(`Limiter request cancelled for ${cortexId}-${name}-${index}: Id: ${info.options.id || 'none'}`);
             endpoint.monitor.incrementErrorCount();
         } else {
-            logger.error(`Limiter request failed for ${cortexId}-${name}-${index}: Id: ${info.options.id || 'none'}: ${error?.message || error}`);
+            const errorMsg = error?.message || error;
+            const status = error?.status || 'unknown';
+            logger.error(`Limiter request failed for ${cortexId}-${name}-${index}: Id: ${info.options.id || 'none'}: [${status}] ${errorMsg}`);
+            // Log response data if available (helpful for debugging 400 errors)
+            if (error?.responseData) {
+                const responseDataStr = typeof error.responseData === 'string'
+                    ? error.responseData.substring(0, 1000)
+                    : JSON.stringify(error.responseData, null, 2).substring(0, 1000);
+                logger.error(`Response data: ${responseDataStr}`);
+            }
         }
     });
 
@@ -239,11 +248,46 @@ const requestWithMonitor = async (endpoint, url, data, axiosConfigObj) => {
     } catch (error) {
         // throw new error with duration as part of the error data
         const { code, name } = error;
-        const finalStatus = error?.response?.status ?? error?.status
-        const statusText = error?.response?.statusText ?? error?.statusText
-        const errorMessage = error?.response?.data?.message ?? error?.response?.data?.error?.message ?? error?.message ?? String(error); 
+        const finalStatus = error?.response?.status ?? error?.status;
+        const statusText = error?.response?.statusText ?? error?.statusText;
+        let responseData = error?.response?.data;
+
+        // For streaming requests with errors, the response data is a stream that needs to be consumed
+        if (responseData && typeof responseData.on === 'function') {
+            try {
+                const chunks = [];
+                for await (const chunk of responseData) {
+                    chunks.push(chunk);
+                }
+                const streamContent = Buffer.concat(chunks).toString('utf-8');
+                try {
+                    responseData = JSON.parse(streamContent);
+                } catch {
+                    responseData = { rawContent: streamContent.substring(0, 2000) };
+                }
+            } catch (streamError) {
+                logger.debug(`Could not read error stream: ${streamError.message}`);
+                responseData = null;
+            }
+        }
+
+        // Extract error message from various possible locations in the response
+        const errorMessage = responseData?.message
+            ?? responseData?.error?.message
+            ?? responseData?.error?.status
+            ?? responseData?.rawContent?.substring(0, 500)
+            ?? error?.message
+            ?? String(error);
+
+        // Log full response data for debugging 4xx errors (especially 400)
+        if (finalStatus >= 400 && finalStatus < 500 && responseData) {
+            const responseDataStr = typeof responseData === 'string'
+                ? responseData.substring(0, 2000)
+                : JSON.stringify(responseData, null, 2).substring(0, 2000);
+            logger.error(`HTTP ${finalStatus} error response data: ${responseDataStr}`);
+        }
 
-        throw { code, message: errorMessage, status: finalStatus, statusText, name, duration: endpoint?.monitor?.incrementErrorCount(callId, finalStatus) };
+        throw { code, message: errorMessage, status: finalStatus, statusText, name, responseData, duration: endpoint?.monitor?.incrementErrorCount(callId, finalStatus) };
     }
     let duration;
     if (response.status >= 200 && response.status < 300) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.32",
+  "version": "1.4.33",
   "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/system/entity/sys_compress_context.js

@@ -0,0 +1,82 @@
+// sys_compress_context.js
+// Compresses chat history containing tool calls and results while preserving critical information
+// Used when context window is approaching limits to prevent 400 errors
+
+import { Prompt } from '../../../server/prompt.js';
+import logger from '../../../lib/logger.js';
+
+export default {
+    prompt: [
+        new Prompt({ messages: [
+            {
+                "role": "system",
+                "content": `You are an AI assistant that compresses conversation history while preserving critical information needed to continue the task.
+
+Your job is to create a concise summary from tool calls and their results that:
+
+1. **Preserves the research intent** - What was the user trying to find or accomplish?
+
+2. **Summarizes tool calls and results** - For each tool call, include:
+   - The tool name and purpose
+   - Key results and findings (especially data, facts, file names, URLs)
+   - Important decisions made based on results
+
+3. **CRITICAL: Preserve exact data** - You MUST preserve:
+   - Exact numbers, percentages, dollar amounts, dates, statistics
+   - ALL URLs exactly as written (never truncate URLs)
+   - Source citations (publication names, report numbers, author names)
+   - File names and paths exactly as they appear
+
+4. **Maintain citation integrity** - Preserve file names, URLs, source references
+
+5. **Keep it actionable** - What has been accomplished? What still needs to be done?
+
+Format as a clear narrative that another AI agent could read to understand the research progress.
+
+Be concise but comprehensive. When in doubt, preserve more detail for numbers, URLs, and citations.`
+            },
+            {
+                "role": "user",
+                "content": `Please compress the following tool calls and results into a concise research summary:
+
+{{{researchContent}}}
+
+Provide a clear summary preserving all URLs, citations, and numerical data.`
+            }
+        ]})
+    ],
+    inputParameters: {
+        researchContent: '',
+        language: "English",
+    },
+    model: 'gemini-flash-3-vision',
+    useInputChunking: false,
+    enableDuplicateRequests: false,
+    timeout: 120,
+    
+    executePathway: async ({args, runAllPrompts}) => {
+        try {
+            // Extract URLs for validation
+            const urls = new Set();
+            const content = args.researchContent || '';
+            const urlMatches = content.match(/https?:\/\/[^\s\)\]"']+/g);
+            if (urlMatches) urlMatches.forEach(url => urls.add(url));
+            
+            const result = await runAllPrompts(args);
+            
+            // Validate URL preservation
+            if (urls.size > 0 && typeof result === 'string') {
+                const preserved = Array.from(urls).filter(url => result.includes(url));
+                const rate = preserved.length / urls.size;
+                if (rate < 0.7) {
+                    logger.warn(`Context compression preserved only ${(rate * 100).toFixed(0)}% of URLs (${preserved.length}/${urls.size})`);
+                }
+            }
+            
+            return result;
+        } catch (error) {
+            logger.error(`Error in sys_compress_context: ${error.message}`);
+            return `[Compression failed] Previous tool calls have been summarized to save context space.`;
+        }
+    }
+};

package/pathways/system/entity/sys_entity_agent.js

@@ -1,8 +1,11 @@
 // sys_entity_agent.js
 // Agentic extension of the entity system that uses OpenAI's tool calling API
 const MAX_TOOL_CALLS = 50;
+const TOOL_TIMEOUT_MS = 120000; // 2 minute timeout per tool call
+const MAX_TOOL_RESULT_LENGTH = 50000; // Truncate oversized tool results to prevent context overflow
 
-import { callPathway, callTool, say, sendToolStart, sendToolFinish } from '../../../lib/pathwayTools.js';
+import { callPathway, callTool, say, sendToolStart, sendToolFinish, withTimeout } from '../../../lib/pathwayTools.js';
+import { publishRequestProgress } from '../../../lib/redisSubscription.js';
 import logger from '../../../lib/logger.js';
 import { config } from '../../../config.js';
 import { syncAndStripFilesFromChatHistory } from '../../../lib/fileUtils.js';
@@ -138,10 +141,13 @@ export default {
                         // Create an isolated copy of messages for this tool
                         const toolMessages = JSON.parse(JSON.stringify(preToolCallMessages));
                         
-                        // Get the tool definition to check for icon
+                        // Get the tool definition to check for icon and timeout
                         const toolDefinition = entityTools[toolFunction]?.definition;
                         const toolIcon = toolDefinition?.icon || '🛠️';
                         
+                        // Get timeout from tool definition or use default
+                        const toolTimeout = toolDefinition?.timeout || TOOL_TIMEOUT_MS;
+                        
                         // Get the user message for the tool
                         const toolUserMessage = toolArgs.userMessage || `Executing tool: ${toolCall.function.name}`;
                         
@@ -155,13 +161,19 @@ export default {
                             // Continue execution even if start message fails
                         }
 
-                        const toolResult = await callTool(toolFunction, {
-                            ...args,
-                            ...toolArgs,
-                            toolFunction,
-                            chatHistory: toolMessages,
-                            stream: false
-                        }, entityTools, pathwayResolver);
+                        // Wrap tool call with timeout to prevent hanging
+                        const toolResult = await withTimeout(
+                            callTool(toolFunction, {
+                                ...args,
+                                ...toolArgs,
+                                toolFunction,
+                                chatHistory: toolMessages,
+                                stream: false,
+                                useMemory: false  // Disable memory synthesis for tool calls
+                            }, entityTools, pathwayResolver),
+                            toolTimeout,
+                            `Tool ${toolCall.function.name} timed out after ${toolTimeout / 1000}s`
+                        );
 
                         // Tool calls and results need to be paired together in the message history
                         // Add the tool call to the isolated message history
@@ -311,7 +323,9 @@ export default {
                             messages: toolMessages
                         };
                     } catch (error) {
-                        logger.error(`Error executing tool ${toolCall?.function?.name || 'unknown'}: ${error.message}`);
+                        // Detect if this is a timeout error for clearer logging
+                        const isTimeout = error.message?.includes('timed out');
+                        logger.error(`${isTimeout ? 'Timeout' : 'Error'} executing tool ${toolCall?.function?.name || 'unknown'}: ${error.message}`);
                         
                         // Send tool finish message (error)
                         // Get requestId and toolCallId if not already defined (in case error occurred before they were set)
@@ -412,7 +426,17 @@ export default {
                 );
             }
 
-            args.chatHistory = finalMessages;
+            // Truncate oversized tool results to prevent context overflow
+            args.chatHistory = finalMessages.map(msg => {
+                if (msg.role === 'tool' && msg.content && msg.content.length > MAX_TOOL_RESULT_LENGTH) {
+                    logger.warn(`Truncating oversized tool result (${msg.content.length} chars) for ${msg.name || 'unknown tool'}`);
+                    return {
+                        ...msg,
+                        content: msg.content.substring(0, MAX_TOOL_RESULT_LENGTH) + '\n\n[Content truncated due to length]'
+                    };
+                }
+                return msg;
+            });
 
             // clear any accumulated pathwayResolver errors from the tools
             pathwayResolver.errors = [];
@@ -429,16 +453,27 @@ export default {
                 
                 // Check if promptAndParse returned null (model call failed)
                 if (!result) {
-                    const errorMessage = pathwayResolver.errors.length > 0 
+                    const errorMessage = pathwayResolver.errors.length > 0
                         ? pathwayResolver.errors.join(', ')
                         : 'Model request failed - no response received';
                     logger.error(`promptAndParse returned null during tool callback: ${errorMessage}`);
                     const errorResponse = await generateErrorResponse(new Error(errorMessage), args, pathwayResolver);
                     // Ensure errors are cleared before returning
                     pathwayResolver.errors = [];
+
+                    // In streaming mode, the toolCallback is invoked fire-and-forget by the plugin,
+                    // so we must stream the error response directly to the client and close the stream
+                    const requestId = pathwayResolver.rootRequestId || pathwayResolver.requestId;
+                    publishRequestProgress({
+                        requestId,
+                        progress: 1,
+                        data: JSON.stringify(errorResponse),
+                        info: JSON.stringify(pathwayResolver.pathwayResultData || {}),
+                        error: ''
+                    });
                     return errorResponse;
                 }
-                
+
                 return result;
             } catch (parseError) {
                 // If promptAndParse fails, generate error response instead of re-throwing
@@ -446,6 +481,17 @@ export default {
                 const errorResponse = await generateErrorResponse(parseError, args, pathwayResolver);
                 // Ensure errors are cleared before returning
                 pathwayResolver.errors = [];
+
+                // In streaming mode, the toolCallback is invoked fire-and-forget by the plugin,
+                // so we must stream the error response directly to the client and close the stream
+                const requestId = pathwayResolver.rootRequestId || pathwayResolver.requestId;
+                publishRequestProgress({
+                    requestId,
+                    progress: 1,
+                    data: JSON.stringify(errorResponse),
+                    info: JSON.stringify(pathwayResolver.pathwayResultData || {}),
+                    error: ''
+                });
                 return errorResponse;
             }
         }
@@ -600,10 +646,10 @@ export default {
 
         // truncate the chat history in case there is really long content
         const truncatedChatHistory = resolver.modelExecutor.plugin.truncateMessagesToTargetLength(args.chatHistory, null, 1000);
-      
+
         // Asynchronously manage memory for this context
         if (args.aiMemorySelfModify && args.useMemory) {
-            callPathway('sys_memory_manager', {  ...args, chatHistory: truncatedChatHistory, stream: false })    
+            callPathway('sys_memory_manager', {  ...args, chatHistory: truncatedChatHistory, stream: false })
             .catch(error => logger.error(error?.message || "Error in sys_memory_manager pathway"));
         }
 
@@ -632,6 +678,10 @@ export default {
             memoryLookupRequired = false;
         }
 
+        // Update pathwayResolver.args with stripped chatHistory
+        // This ensures toolCallback receives the processed history, not the original
+        pathwayResolver.args = {...args};
+
         try {
             let currentMessages = JSON.parse(JSON.stringify(args.chatHistory));
 

package/pathways/transcribe_gemini.js

@@ -225,7 +225,7 @@ REMEMBER:
                     .sort((a, b) => a.index - b.index)
                     .map(item => item.result);
             } catch (error) {
-                logger.error('Error processing chunks:', error);
+                logger.error(`Error processing chunks: ${error.message}`);
                 throw error;
             }
         };

package/server/modelExecutor.js

@@ -26,6 +26,7 @@ import Gemini3ImagePlugin from './plugins/gemini3ImagePlugin.js';
 import Gemini3ReasoningVisionPlugin from './plugins/gemini3ReasoningVisionPlugin.js';
 import Claude3VertexPlugin from './plugins/claude3VertexPlugin.js';
 import Claude4VertexPlugin from './plugins/claude4VertexPlugin.js';
+import ClaudeAnthropicPlugin from './plugins/claudeAnthropicPlugin.js';
 import NeuralSpacePlugin from './plugins/neuralSpacePlugin.js';
 import RunwareAiPlugin from './plugins/runwareAiPlugin.js';
 import ReplicateApiPlugin from './plugins/replicateApiPlugin.js';
@@ -122,6 +123,9 @@ class ModelExecutor {
             case 'CLAUDE-4-VERTEX':
                 plugin = new Claude4VertexPlugin(pathway, model);
                 break;
+            case 'CLAUDE-ANTHROPIC':
+                plugin = new ClaudeAnthropicPlugin(pathway, model);
+                break;
             case 'RUNWARE-AI':
                 plugin = new RunwareAiPlugin(pathway, model);
                 break;