@aj-archipelago/cortex 1.3.63 → 1.3.64

package/lib/entityConstants.js

@@ -145,7 +145,7 @@ Privacy is critical. If asked to forget or delete something, always comply affir
     AI_DATETIME: "# Time, Date, and Time Zone\n\nThe current time and date in GMT is {{now}}, but references like \"today\" or \"yesterday\" are relative to the user's time zone. If you remember the user's time zone, use it - it's possible that the day for the user is different than the day in GMT.",
 
     AI_STYLE_OPENAI: "oai-gpt41",
-    AI_STYLE_OPENAI_RESEARCH: "oai-o3",
+    AI_STYLE_OPENAI_RESEARCH: "oai-gpt5",
     AI_STYLE_ANTHROPIC: "claude-4-sonnet-vertex",
     AI_STYLE_ANTHROPIC_RESEARCH: "claude-41-opus-vertex",
     AI_STYLE_XAI: "xai-grok-4-fast-reasoning",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.63",
+  "version": "1.3.64",
   "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/memory/shared/sys_memory_helpers.js

@@ -34,7 +34,7 @@ const normalizeMemoryFormat = async (args, content) => {
                 formattedContent = [...validLines, ...formattedBlock.split('\n')];
             }
         } catch (error) {
-            logger.warn('Error formatting invalid memory lines:', error);
+            logger.warn(`Error formatting invalid memory lines: ${error?.message || 'Unknown error'}`);
         }
     }
 

package/pathways/system/entity/memory/sys_memory_manager.js

@@ -123,7 +123,7 @@ export default {
                 return "";
 
             } catch (e) {
-                logger.warn('sys_memory_required returned invalid JSON:', memoryRequired);
+                logger.warn(`sys_memory_required returned invalid JSON: ${JSON.stringify(memoryRequired)}`);
                 return "";
             }
 

package/pathways/system/entity/sys_entity_agent.js

@@ -43,9 +43,12 @@ export default {
         // Handle both CortexResponse objects and plain message objects
         let tool_calls;
         if (message instanceof CortexResponse) {
-            tool_calls = message.toolCalls || message.functionCall ? [message.functionCall] : null;
+            tool_calls = [...(message.toolCalls || [])];
+            if (message.functionCall) {
+                tool_calls.push(message.functionCall);
+            }
         } else {
-            tool_calls = message.tool_calls;
+            tool_calls = [...(message.tool_calls || [])];
         }
         
         const pathwayResolver = resolver;
@@ -56,10 +59,20 @@ export default {
         const preToolCallMessages = JSON.parse(JSON.stringify(args.chatHistory || []));
         const finalMessages = JSON.parse(JSON.stringify(preToolCallMessages));
 
-        if (tool_calls) {
+        if (tool_calls && tool_calls.length > 0) {
             if (pathwayResolver.toolCallCount < MAX_TOOL_CALLS) {
                 // Execute tool calls in parallel but with isolated message histories
-                const toolResults = await Promise.all(tool_calls.map(async (toolCall) => {
+                // Filter out any undefined or invalid tool calls
+                const invalidToolCalls = tool_calls.filter(tc => !tc || !tc.function || !tc.function.name);
+                if (invalidToolCalls.length > 0) {
+                    logger.warn(`Found ${invalidToolCalls.length} invalid tool calls: ${JSON.stringify(invalidToolCalls, null, 2)}`);
+                    // bail out if we're getting invalid tool calls
+                    pathwayResolver.toolCallCount = MAX_TOOL_CALLS;
+                }
+                
+                const validToolCalls = tool_calls.filter(tc => tc && tc.function && tc.function.name);
+                
+                const toolResults = await Promise.all(validToolCalls.map(async (toolCall) => {
                     try {
                         if (!toolCall?.function?.arguments) {
                             throw new Error('Invalid tool call structure: missing function arguments');
@@ -192,7 +205,7 @@ export default {
                 }
 
                 // Check if any tool calls failed
-                const failedTools = toolResults.filter(result => !result.success);
+                const failedTools = toolResults.filter(result => result && !result.success);
                 if (failedTools.length > 0) {
                     logger.warn(`Some tool calls failed: ${failedTools.map(t => t.error).join(', ')}`);
                 }

package/pathways/system/entity/sys_generator_results.js

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

package/server/plugins/gemini15VisionPlugin.js

@@ -464,11 +464,13 @@ class Gemini15VisionPlugin extends Gemini15ChatPlugin {
             const pathwayResolver = requestState[this.requestId]?.pathwayResolver;
 
             if (finishReason === 'tool_calls' && this.toolCallsBuffer.length > 0 && this.pathwayToolCallback && pathwayResolver) {
+                // Filter out undefined elements from the tool calls buffer
+                const validToolCalls = this.toolCallsBuffer.filter(tc => tc && tc.function && tc.function.name);
                 // Execute tool callback and keep stream open
                 const toolMessage = {
                     role: 'assistant',
                     content: this.contentBuffer || '',
-                    tool_calls: this.toolCallsBuffer,
+                    tool_calls: validToolCalls,
                 };
                 this.pathwayToolCallback(pathwayResolver?.args, toolMessage, pathwayResolver);
                 // Clear tool buffer after processing; keep content for citations/continuations

package/server/plugins/openAiVisionPlugin.js

@@ -280,10 +280,12 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
                     case 'tool_calls':
                         // Process complete tool calls when we get the finish reason
                         if (this.pathwayToolCallback && this.toolCallsBuffer.length > 0 && pathwayResolver) {
+                            // Filter out undefined elements from the tool calls buffer
+                            const validToolCalls = this.toolCallsBuffer.filter(tc => tc && tc.function && tc.function.name);
                             const toolMessage = {
                                 role: 'assistant',
                                 content: delta?.content || '', 
-                                tool_calls: this.toolCallsBuffer,
+                                tool_calls: validToolCalls,
                             };
                             this.pathwayToolCallback(pathwayResolver?.args, toolMessage, pathwayResolver);
                         }

package/tests/helpers/sseClient.js

@@ -7,7 +7,7 @@ export async function connectToSSEEndpoint(baseUrl, endpoint, payload, onEvent)
     let sawDone = false;
     const timeout = setTimeout(() => {
       reject(new Error('SSE timeout waiting for [DONE]'));
-    }, 8000); // 8 second timeout
+    }, 20000); // 20 second timeout
     
     try {
       const instance = axios.create({

package/tests/unit/plugins/toolCallBufferFiltering.test.js

@@ -0,0 +1,297 @@
+import test from 'ava';
+import OpenAIVisionPlugin from '../../../server/plugins/openAiVisionPlugin.js';
+import Gemini15VisionPlugin from '../../../server/plugins/gemini15VisionPlugin.js';
+import { PathwayResolver } from '../../../server/pathwayResolver.js';
+import { config } from '../../../config.js';
+import { requestState } from '../../../server/requestState.js';
+
+// Mock logger to prevent issues in tests
+const mockLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+
+// Mock the logger module globally
+global.logger = mockLogger;
+
+function createResolverWithPlugin(pluginClass, modelName = 'test-model') {
+  const pluginToModelType = {
+    OpenAIVisionPlugin: 'OPENAI-VISION',
+    Gemini15VisionPlugin: 'GEMINI-1.5-VISION'
+  };
+
+  const modelType = pluginToModelType[pluginClass.name];
+  if (!modelType) {
+    throw new Error(`Unknown plugin class: ${pluginClass.name}`);
+  }
+
+  const pathway = {
+    name: 'test-pathway',
+    model: modelName,
+    prompt: 'test prompt',
+    toolCallback: () => {} // Mock tool callback
+  };
+  
+  const model = {
+    name: modelName,
+    type: modelType
+  };
+  
+  const resolver = new PathwayResolver({ 
+    config,
+    pathway,
+    args: {},
+    endpoints: { [modelName]: model }
+  });
+  
+  resolver.modelExecutor.plugin = new pluginClass(pathway, model);
+  return resolver;
+}
+
+test('OpenAIVisionPlugin - filters undefined tool calls from buffer', async t => {
+  const resolver = createResolverWithPlugin(OpenAIVisionPlugin);
+  const plugin = resolver.modelExecutor.plugin;
+  
+  // Simulate the scenario where tool calls start at index 1, leaving index 0 undefined
+  plugin.toolCallsBuffer[0] = undefined; // This is what causes the issue
+  plugin.toolCallsBuffer[1] = {
+    id: 'call_1_1234567890',
+    type: 'function',
+    function: {
+      name: 'test_tool',
+      arguments: '{"param": "value"}'
+    }
+  };
+  
+  // Mock the tool callback to capture what gets passed
+  let capturedToolCalls = null;
+  plugin.pathwayToolCallback = (args, message, resolver) => {
+    capturedToolCalls = message.tool_calls;
+  };
+  
+  // Mock requestProgress and pathwayResolver
+  const requestProgress = { progress: 0, started: true };
+  const pathwayResolver = { args: {} };
+  
+  // Mock requestState to return our resolver
+  requestState[plugin.requestId] = { pathwayResolver };
+  
+  // Simulate a tool_calls finish reason
+  const event = {
+    data: JSON.stringify({
+      choices: [{
+        finish_reason: 'tool_calls'
+      }]
+    })
+  };
+  
+  // Process the stream event
+  plugin.processStreamEvent(event, requestProgress);
+  
+  // Verify that undefined elements were filtered out
+  t.truthy(capturedToolCalls, 'Tool callback should have been called');
+  t.is(capturedToolCalls.length, 1, 'Should have filtered out undefined elements');
+  t.is(capturedToolCalls[0].function.name, 'test_tool', 'Valid tool call should be preserved');
+  
+  // Clean up
+  delete requestState[plugin.requestId];
+});
+
+test('OpenAIVisionPlugin - handles empty buffer gracefully', async t => {
+  const resolver = createResolverWithPlugin(OpenAIVisionPlugin);
+  const plugin = resolver.modelExecutor.plugin;
+  
+  // Empty buffer
+  plugin.toolCallsBuffer = [];
+  
+  // Mock the tool callback
+  let callbackCalled = false;
+  plugin.pathwayToolCallback = () => {
+    callbackCalled = true;
+  };
+  
+  // Mock requestProgress and pathwayResolver
+  const requestProgress = { progress: 0, started: true };
+  const pathwayResolver = { args: {} };
+  
+  // Mock requestState
+  requestState[plugin.requestId] = { pathwayResolver };
+  
+  // Simulate a tool_calls finish reason
+  const event = {
+    data: JSON.stringify({
+      choices: [{
+        finish_reason: 'tool_calls'
+      }]
+    })
+  };
+  
+  // Process the stream event
+  plugin.processStreamEvent(event, requestProgress);
+  
+  // Verify that callback was not called with empty buffer
+  t.falsy(callbackCalled, 'Tool callback should not be called with empty buffer');
+  
+  // Clean up
+  delete requestState[plugin.requestId];
+});
+
+test('OpenAIVisionPlugin - filters invalid tool calls', async t => {
+  const resolver = createResolverWithPlugin(OpenAIVisionPlugin);
+  const plugin = resolver.modelExecutor.plugin;
+  
+  // Create buffer with mixed valid and invalid tool calls
+  plugin.toolCallsBuffer[0] = undefined;
+  plugin.toolCallsBuffer[1] = {
+    id: 'call_1_1234567890',
+    type: 'function',
+    function: {
+      name: 'valid_tool',
+      arguments: '{"param": "value"}'
+    }
+  };
+  plugin.toolCallsBuffer[2] = {
+    id: 'call_2_1234567890',
+    type: 'function',
+    function: {
+      name: '', // Invalid: empty name
+      arguments: '{"param": "value"}'
+    }
+  };
+  plugin.toolCallsBuffer[3] = {
+    id: 'call_3_1234567890',
+    type: 'function',
+    function: {
+      name: 'another_valid_tool',
+      arguments: '{"param": "value"}'
+    }
+  };
+  
+  // Mock the tool callback
+  let capturedToolCalls = null;
+  plugin.pathwayToolCallback = (args, message, resolver) => {
+    capturedToolCalls = message.tool_calls;
+  };
+  
+  // Mock requestProgress and pathwayResolver
+  const requestProgress = { progress: 0, started: true };
+  const pathwayResolver = { args: {} };
+  
+  // Mock requestState
+  requestState[plugin.requestId] = { pathwayResolver };
+  
+  // Simulate a tool_calls finish reason
+  const event = {
+    data: JSON.stringify({
+      choices: [{
+        finish_reason: 'tool_calls'
+      }]
+    })
+  };
+  
+  // Process the stream event
+  plugin.processStreamEvent(event, requestProgress);
+  
+  // Verify that only valid tool calls were passed
+  t.truthy(capturedToolCalls, 'Tool callback should have been called');
+  t.is(capturedToolCalls.length, 2, 'Should have filtered out invalid elements');
+  t.is(capturedToolCalls[0].function.name, 'valid_tool', 'First valid tool call should be preserved');
+  t.is(capturedToolCalls[1].function.name, 'another_valid_tool', 'Second valid tool call should be preserved');
+  
+  // Clean up
+  delete requestState[plugin.requestId];
+});
+
+test('Gemini15VisionPlugin - filters undefined tool calls from buffer', async t => {
+  const resolver = createResolverWithPlugin(Gemini15VisionPlugin);
+  const plugin = resolver.modelExecutor.plugin;
+  
+  // Simulate buffer with undefined elements (though less likely with push method)
+  plugin.toolCallsBuffer = [
+    undefined,
+    {
+      id: 'call_1_1234567890',
+      type: 'function',
+      function: {
+        name: 'test_tool',
+        arguments: '{"param": "value"}'
+      }
+    }
+  ];
+  
+  // Mock the tool callback
+  let capturedToolCalls = null;
+  plugin.pathwayToolCallback = (args, message, resolver) => {
+    capturedToolCalls = message.tool_calls;
+  };
+  
+  // Mock requestProgress and pathwayResolver
+  const requestProgress = { progress: 0, started: true };
+  const pathwayResolver = { args: {} };
+  
+  // Mock requestState
+  requestState[plugin.requestId] = { pathwayResolver };
+  
+  // Simulate a tool_calls finish reason
+  const eventData = {
+    candidates: [{
+      finishReason: 'STOP'
+    }]
+  };
+  
+  // Set hadToolCalls to true to trigger tool_calls finish reason
+  plugin.hadToolCalls = true;
+  
+  // Process the stream event
+  plugin.processStreamEvent({ data: JSON.stringify(eventData) }, requestProgress);
+  
+  // Verify that undefined elements were filtered out
+  t.truthy(capturedToolCalls, 'Tool callback should have been called');
+  t.is(capturedToolCalls.length, 1, 'Should have filtered out undefined elements');
+  t.is(capturedToolCalls[0].function.name, 'test_tool', 'Valid tool call should be preserved');
+  
+  // Clean up
+  delete requestState[plugin.requestId];
+});
+
+test('Gemini15VisionPlugin - handles empty buffer gracefully', async t => {
+  const resolver = createResolverWithPlugin(Gemini15VisionPlugin);
+  const plugin = resolver.modelExecutor.plugin;
+  
+  // Empty buffer
+  plugin.toolCallsBuffer = [];
+  
+  // Mock the tool callback
+  let callbackCalled = false;
+  plugin.pathwayToolCallback = () => {
+    callbackCalled = true;
+  };
+  
+  // Mock requestProgress and pathwayResolver
+  const requestProgress = { progress: 0, started: true };
+  const pathwayResolver = { args: {} };
+  
+  // Mock requestState
+  requestState[plugin.requestId] = { pathwayResolver };
+  
+  // Simulate a tool_calls finish reason
+  const eventData = {
+    candidates: [{
+      finishReason: 'STOP'
+    }]
+  };
+  
+  // Set hadToolCalls to true
+  plugin.hadToolCalls = true;
+  
+  // Process the stream event
+  plugin.processStreamEvent({ data: JSON.stringify(eventData) }, requestProgress);
+  
+  // Verify that callback was not called with empty buffer
+  t.falsy(callbackCalled, 'Tool callback should not be called with empty buffer');
+  
+  // Clean up
+  delete requestState[plugin.requestId];
+});