@aj-archipelago/cortex 1.4.31 → 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}`);
     }
   }
 
@@ -349,6 +349,7 @@ class PathwayManager {
     const promptName = typeof promptItem === 'string' ? defaultName : (promptItem.name || defaultName);
     const promptFiles = typeof promptItem === 'string' ? [] : (promptItem.files || []);
     const cortexPathwayName = typeof promptItem === 'string' ? null : (promptItem.cortexPathwayName || null);
+    const researchMode = typeof promptItem === 'string' ? undefined : (promptItem.researchMode !== undefined ? promptItem.researchMode : undefined);
     
     const messages = [];
 
@@ -383,6 +384,11 @@ class PathwayManager {
       prompt.cortexPathwayName = cortexPathwayName;
     }
 
+    // Preserve researchMode if present
+    if (researchMode !== undefined) {
+      prompt.researchMode = researchMode;
+    }
+
     return prompt;
   }
 
@@ -460,6 +466,7 @@ class PathwayManager {
       prompt: String!
       files: [String!]
       cortexPathwayName: String
+      researchMode: Boolean
     }
     
     input PathwayInput {
@@ -537,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

@@ -6,6 +6,7 @@ import { getSemanticChunks } from "../server/chunker.js";
 import logger from '../lib/logger.js';
 import { requestState } from '../server/requestState.js';
 import { processPathwayParameters } from '../server/typeDef.js';
+import { waitForClientToolResult } from '../server/clientToolCallbacks.js';
 
 // callPathway - call a pathway from another pathway
 const callPathway = async (pathwayName, inArgs, pathwayResolver) => {
@@ -91,6 +92,76 @@ const callTool = async (toolName, args, toolDefinitions, pathwayResolver) => {
     logger.debug(`callTool: Starting execution of ${toolName} ${JSON.stringify(logArgs)}`);
 
     try {
+        // Check if this is a client-side tool
+        if (toolDef.clientSide === true || toolDef.definition?.clientSide === true) {
+            logger.info(`Tool ${toolName} is a client-side tool - waiting for client execution`);
+            
+            const toolCallbackId = `${toolName}_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+            
+            // Explicitly publish the marker to the stream so the client receives it
+            if (pathwayResolver) {
+                const requestId = pathwayResolver.rootRequestId || pathwayResolver.requestId;
+                
+                const toolCallbackData = {
+                    toolUsed: [toolName],
+                    clientSideTool: true,
+                    toolCallbackName: toolName,
+                    toolCallbackId: toolCallbackId,
+                    toolCallbackMessage: args.userMessage || `Executing ${toolName}...`,
+                    chatId: args.chatId || "",
+                    requestId: requestId, // Include requestId so client can submit tool results
+                    toolArgs: args
+                };
+                
+                try {
+                    logger.info(`Publishing client-side tool marker to requestId: ${requestId}, toolCallbackId: ${toolCallbackId}`);
+                    await publishRequestProgress({
+                        requestId,
+                        progress: 0.5,
+                        data: JSON.stringify(""),
+                        info: JSON.stringify(toolCallbackData)
+                    });
+                } catch (error) {
+                    logger.error(`Error publishing client-side tool marker: ${error.message}`);
+                    throw error;
+                }
+                
+                // Wait for the client to execute the tool and send back the result
+                logger.info(`Waiting for client tool result: ${toolCallbackId}`);
+                try {
+                    // Use 5 minute timeout to accommodate longer operations like CreateApplet
+                    const clientResult = await waitForClientToolResult(toolCallbackId, requestId, 300000);
+                    logger.info(`Received client tool result for ${toolCallbackId}: ${JSON.stringify(clientResult).substring(0, 200)}`);
+                    
+                    // If the client reported an error, throw it
+                    if (!clientResult.success) {
+                        throw new Error(clientResult.error || 'Client tool execution failed');
+                    }
+                    
+                    // Return the client's result
+                    toolResult = typeof clientResult.data === 'string' 
+                        ? clientResult.data 
+                        : JSON.stringify(clientResult.data);
+                    
+                    // Update resolver with tool result
+                    pathwayResolver.tool = JSON.stringify({
+                        ...toolCallbackData,
+                        result: clientResult.data
+                    });
+                    
+                    return {
+                        result: toolResult,
+                        images: []
+                    };
+                } catch (error) {
+                    logger.error(`Error waiting for client tool result: ${error.message}`);
+                    throw new Error(`Client tool execution failed: ${error.message}`);
+                }
+            } else {
+                throw new Error('PathwayResolver is required for client-side tools');
+            }
+        }
+
         const pathwayName = toolDef.pathwayName;
         // Merge hard-coded pathway parameters with runtime args
         const mergedArgs = {
@@ -356,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.31",
+  "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.`;
+        }
+    }
+};