@aj-archipelago/cortex 1.3.62 → 1.3.63

package/tests/{parser.test.js → unit/core/parser.test.js}

@@ -1,7 +1,7 @@
 import test from 'ava';
-import * as parser from '../server/parser.js';
-import * as pathwayTools from '../lib/pathwayTools.js';
-import serverFactory from '../index.js';
+import * as parser from '../../../server/parser.js';
+import * as pathwayTools from '../../../lib/pathwayTools.js';
+import serverFactory from '../../../index.js';
 
 let testServer;
 

package/tests/unit/core/pathwayResolver.test.js

@@ -0,0 +1,187 @@
+import test from 'ava';
+import { PathwayResolver } from '../../../server/pathwayResolver.js';
+import sinon from 'sinon';
+import { mockConfig, mockPathwayString, mockModelEndpoints } from '../../helpers/mocks.js';
+
+const mockPathway = mockPathwayString;
+mockPathway.useInputChunking = false;
+mockPathway.prompt = 'What is AI?';
+
+const mockArgs = {
+  text: 'Artificial intelligence',
+};
+
+test.beforeEach((t) => {
+  t.context.pathwayResolver = new PathwayResolver({
+    config: mockConfig,
+    pathway: mockPathway,
+    args: mockArgs,
+    endpoints: mockModelEndpoints,
+  });
+});
+
+test('constructor initializes properties correctly', (t) => {
+  const resolver = t.context.pathwayResolver;
+  t.deepEqual(resolver.config, mockConfig);
+  t.deepEqual(resolver.pathway, mockPathway);
+  t.deepEqual(resolver.args, mockArgs);
+  t.is(resolver.useInputChunking, mockPathway.useInputChunking);
+  t.is(typeof resolver.requestId, 'string');
+});
+
+test('resolve returns request id when async is true', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const requestId = await resolver.resolve({ ...mockArgs, async: true });
+  t.is(typeof requestId, 'string');
+  t.is(requestId, resolver.requestId);
+});
+
+test('resolve calls promptAndParse when async is false', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const promptAndParseStub = sinon.stub(resolver, 'promptAndParse').returns(Promise.resolve('test-result'));
+
+  const result = await resolver.resolve(mockArgs);
+  t.true(promptAndParseStub.calledOnce);
+  t.is(result, 'test-result');
+});
+
+test('processInputText returns input text if no chunking', (t) => {
+  const resolver = t.context.pathwayResolver;
+  const text = 'This is a test input text';
+  const result = resolver.processInputText(text);
+  t.deepEqual(result, [text]);
+});
+
+test('applyPromptsSerially returns result of last prompt', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const text = 'This is a test input text';
+  const applyPromptStub = sinon.stub(resolver, 'applyPrompt');
+  applyPromptStub.onCall(0).returns(Promise.resolve('result1'));
+  applyPromptStub.onCall(1).returns(Promise.resolve('result2'));
+
+  resolver.pathwayPrompt = ['prompt1', 'prompt2'];
+  const result = await resolver.applyPromptsSerially(text, mockArgs);
+
+  t.is(result, 'result2');
+});
+
+test('processRequest returns empty result when input text is empty', async (t) => {
+    const resolver = t.context.pathwayResolver;
+    const text = '';
+    const processRequestStub = sinon.stub(resolver, 'processRequest').returns(Promise.resolve(''));
+  
+    await resolver.resolve({ ...mockArgs, text });
+  
+    t.true(processRequestStub.calledOnce);
+    const returnValue = await processRequestStub.firstCall.returnValue;
+    t.is(returnValue, text);
+  });
+
+test('swapModel successfully changes model', (t) => {
+  const resolver = t.context.pathwayResolver;
+  const originalModelName = resolver.modelName;
+  const originalModel = resolver.model;
+  const originalModelExecutor = resolver.modelExecutor;
+  
+  // Mock the getChunkMaxTokenLength method to avoid complex calculations
+  const getChunkMaxTokenLengthStub = sinon.stub(resolver, 'getChunkMaxTokenLength').returns(1000);
+  
+  // Find a different model name from the mock endpoints
+  const availableModels = Object.keys(mockModelEndpoints);
+  const newModelName = availableModels.find(name => name !== originalModelName) || availableModels[0];
+  
+  resolver.swapModel(newModelName);
+  
+  t.not(resolver.modelName, originalModelName);
+  t.is(resolver.modelName, newModelName);
+  t.not(resolver.model, originalModel);
+  t.is(resolver.model, mockModelEndpoints[newModelName]);
+  t.not(resolver.modelExecutor, originalModelExecutor);
+  t.true(getChunkMaxTokenLengthStub.calledOnce);
+  
+  getChunkMaxTokenLengthStub.restore();
+});
+
+test('swapModel throws error for non-existent model', (t) => {
+  const resolver = t.context.pathwayResolver;
+  
+  t.throws(() => {
+    resolver.swapModel('non-existent-model');
+  }, { message: 'Model non-existent-model not found in config' });
+});
+
+test('swapModel logs warning about model change', (t) => {
+  const resolver = t.context.pathwayResolver;
+  const logWarningStub = sinon.stub(resolver, 'logWarning');
+  
+  // Find a different model name from the mock endpoints
+  const availableModels = Object.keys(mockModelEndpoints);
+  const newModelName = availableModels.find(name => name !== resolver.modelName) || availableModels[0];
+  
+  resolver.swapModel(newModelName);
+  
+  t.true(logWarningStub.calledWith(`Model swapped to ${newModelName}`));
+  
+  logWarningStub.restore();
+});
+
+test('promptAndParse swaps model when model is specified in args', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const swapModelStub = sinon.stub(resolver, 'swapModel');
+  const processRequestStub = sinon.stub(resolver, 'processRequest').returns(Promise.resolve('test result'));
+  
+  // Mock the response parser to return the result directly
+  const parseStub = sinon.stub(resolver.responseParser, 'parse').returns(Promise.resolve('test result'));
+  
+  const argsWithModel = { ...mockArgs, modelOverride: 'anotherModel' };
+  
+  await resolver.promptAndParse(argsWithModel);
+  
+  t.true(swapModelStub.calledWith('anotherModel'));
+  
+  swapModelStub.restore();
+  processRequestStub.restore();
+  parseStub.restore();
+});
+
+test('promptAndParse does not swap model when model is same as current', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const swapModelStub = sinon.stub(resolver, 'swapModel');
+  const processRequestStub = sinon.stub(resolver, 'processRequest').returns(Promise.resolve('test result'));
+  
+  // Mock the response parser to return the result directly
+  const parseStub = sinon.stub(resolver.responseParser, 'parse').returns(Promise.resolve('test result'));
+  
+  const argsWithSameModel = { ...mockArgs, model: resolver.modelName };
+  
+  await resolver.promptAndParse(argsWithSameModel);
+  
+  t.false(swapModelStub.called);
+  
+  swapModelStub.restore();
+  processRequestStub.restore();
+  parseStub.restore();
+});
+
+test('promptAndParse handles model swap errors gracefully', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const logErrorStub = sinon.stub(resolver, 'logError');
+  const processRequestStub = sinon.stub(resolver, 'processRequest').returns(Promise.resolve('test result'));
+  
+  // Mock the response parser to return the result directly
+  const parseStub = sinon.stub(resolver.responseParser, 'parse').returns(Promise.resolve('test result'));
+  
+  // Mock swapModel to throw an error
+  const swapModelStub = sinon.stub(resolver, 'swapModel').throws(new Error('Model not found'));
+  
+  const argsWithInvalidModel = { ...mockArgs, modelOverride: 'invalidModel' };
+  
+  await resolver.promptAndParse(argsWithInvalidModel);
+  
+  t.true(logErrorStub.calledWith('Failed to swap model to invalidModel: Model not found'));
+  
+  swapModelStub.restore();
+  logErrorStub.restore();
+  processRequestStub.restore();
+  parseStub.restore();
+});

package/tests/{requestMonitor.test.js → unit/core/requestMonitor.test.js}

@@ -1,5 +1,5 @@
 import test from 'ava';
-import RequestMonitor from '../lib/requestMonitor.js'; // replace with actual path
+import RequestMonitor from '../../../lib/requestMonitor.js'; // replace with actual path
 
 test('RequestMonitor: startCall', t => {
   const rm = new RequestMonitor();

package/tests/{requestMonitorDurationEstimator.test.js → unit/core/requestMonitorDurationEstimator.test.js}

@@ -1,5 +1,5 @@
 import test from 'ava';
-import RequestMonitor from '../lib/requestMonitor.js';
+import RequestMonitor from '../../../lib/requestMonitor.js';
 
 test('add and get average request duration', async (t) => {
     const estimator = new RequestMonitor(5);

package/tests/{truncateMessages.test.js → unit/core/truncateMessages.test.js}

@@ -1,8 +1,8 @@
 // ModelPlugin.test.js
 import test from 'ava';
-import ModelPlugin from '../server/plugins/modelPlugin.js';
-import { encode } from '../lib/encodeCache.js';
-import { mockPathwayResolverString } from './mocks.js';
+import ModelPlugin from '../../../server/plugins/modelPlugin.js';
+import { encode } from '../../../lib/encodeCache.js';
+import { mockPathwayResolverString } from '../../helpers/mocks.js';
 
 const { config, pathway, modelName, model } = mockPathwayResolverString;
 

package/tests/{util.test.js → unit/core/util.test.js}

@@ -2,7 +2,7 @@
 // Tests for utility functions in cortex/lib/util.js
 
 import test from 'ava';
-import { removeOldImageAndFileContent } from '../lib/util.js';
+import { removeOldImageAndFileContent } from '../../../lib/util.js';
 
 // Test removeOldImageAndFileContent function
 

package/tests/{apptekTranslatePlugin.test.js → unit/plugins/apptekTranslatePlugin.test.js}

@@ -1,8 +1,8 @@
 import test from 'ava';
 import sinon from 'sinon';
-import ApptekTranslatePlugin from '../server/plugins/apptekTranslatePlugin.js';
-import { config } from '../config.js';
-import * as pathwayTools from '../lib/pathwayTools.js';
+import ApptekTranslatePlugin from '../../../server/plugins/apptekTranslatePlugin.js';
+import { config } from '../../../config.js';
+import * as pathwayTools from '../../../lib/pathwayTools.js';
 
 // Mock pathway and model
 const mockPathway = {

package/tests/{azureFoundryAgents.test.js → unit/plugins/azureFoundryAgents.test.js}

@@ -1,6 +1,6 @@
 // azureFoundryAgents.test.js
 import test from 'ava';
-import AzureFoundryAgentsPlugin from '../server/plugins/azureFoundryAgentsPlugin.js';
+import AzureFoundryAgentsPlugin from '../../../server/plugins/azureFoundryAgentsPlugin.js';
 
 test.beforeEach(t => {
     const mockPathway = {
@@ -87,6 +87,141 @@ test('should create correct request parameters', t => {
     t.is(result.stream, false);
 });
 
+test('should use custom instructions from parameters', t => {
+    const { plugin } = t.context;
+    const text = 'Hello, can you help me?';
+    const customInstructions = 'You are a specialized search agent.';
+    const parameters = { 
+        stream: false,
+        instructions: customInstructions
+    };
+    const prompt = {
+        context: 'You are helpful.',
+        examples: [],
+        messages: [{ role: 'user', content: text }]
+    };
+
+    plugin.baseUrl = 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry';
+    plugin.assistantId = 'asst_testid';
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.is(result.instructions, customInstructions);
+});
+
+test('should use custom tools from parameters', t => {
+    const { plugin } = t.context;
+    const text = 'Hello, can you help me?';
+    const customTools = [
+        {
+            type: "bing_grounding",
+            bing_grounding: {
+                search_configurations: [
+                    {
+                        connection_id: "test-connection-id",
+                        count: 10,
+                        freshness: "day",
+                        market: "en-us",
+                        set_lang: "en"
+                    }
+                ]
+            }
+        }
+    ];
+    const parameters = { 
+        stream: false,
+        tools: customTools
+    };
+    const prompt = {
+        context: 'You are helpful.',
+        examples: [],
+        messages: [{ role: 'user', content: text }]
+    };
+
+    plugin.baseUrl = 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry';
+    plugin.assistantId = 'asst_testid';
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.deepEqual(result.tools, customTools);
+});
+
+test('should use custom parallel_tool_calls from parameters', t => {
+    const { plugin } = t.context;
+    const text = 'Hello, can you help me?';
+    const parameters = { 
+        stream: false,
+        parallel_tool_calls: false
+    };
+    const prompt = {
+        context: 'You are helpful.',
+        examples: [],
+        messages: [{ role: 'user', content: text }]
+    };
+
+    plugin.baseUrl = 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry';
+    plugin.assistantId = 'asst_testid';
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.is(result.parallel_tool_calls, false);
+});
+
+test('should not include tools or parallel_tool_calls when not provided', t => {
+    const { plugin } = t.context;
+    const text = 'Hello, can you help me?';
+    const parameters = { stream: false };
+    const prompt = {
+        context: 'You are helpful.',
+        examples: [],
+        messages: [{ role: 'user', content: text }]
+    };
+
+    plugin.baseUrl = 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry';
+    plugin.assistantId = 'asst_testid';
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.falsy(result.tools);
+    t.falsy(result.parallel_tool_calls);
+});
+
+test('should handle Bing grounding tools with custom search parameters', t => {
+    const { plugin } = t.context;
+    const text = 'Hello, can you help me?';
+    const customTools = [
+        {
+            type: "bing_grounding",
+            bing_grounding: {
+                search_configurations: [
+                    {
+                        connection_id: "test-connection-id",
+                        count: 10,
+                        freshness: "day",
+                        market: "en-gb",
+                        set_lang: "en"
+                    }
+                ]
+            }
+        }
+    ];
+    const parameters = { 
+        stream: false,
+        tools: customTools
+    };
+    const prompt = {
+        context: 'You are helpful.',
+        examples: [],
+        messages: [{ role: 'user', content: text }]
+    };
+
+    plugin.baseUrl = 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry';
+    plugin.assistantId = 'asst_testid';
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.deepEqual(result.tools, customTools);
+    t.is(result.tools[0].bing_grounding.search_configurations[0].count, 10);
+    t.is(result.tools[0].bing_grounding.search_configurations[0].freshness, "day");
+    t.is(result.tools[0].bing_grounding.search_configurations[0].market, "en-gb");
+    t.is(result.tools[0].bing_grounding.search_configurations[0].set_lang, "en");
+});
+
 test('should parse completed run response', t => {
     const { plugin } = t.context;
     const mockResponse = {

package/tests/{claude3VertexPlugin.test.js → unit/plugins/claude3VertexPlugin.test.js}

@@ -1,7 +1,7 @@
 import test from 'ava';
-import Claude3VertexPlugin from '../server/plugins/claude3VertexPlugin.js';
-import { mockPathwayResolverMessages } from './mocks.js';
-import { config } from '../config.js';
+import Claude3VertexPlugin from '../../../server/plugins/claude3VertexPlugin.js';
+import { mockPathwayResolverMessages } from '../../helpers/mocks.js';
+import { config } from '../../../config.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -137,26 +137,48 @@ test('getRequestParameters with long message in chatHistory', async (t) => {
 test('parseResponse', (t) => {
     const plugin = new Claude3VertexPlugin(pathway, model);
 
+    // Test text content response
     const dataWithTextContent = {
         content: [
             { type: 'text', text: 'Hello, World!' }
-        ]
+        ],
+        usage: { input_tokens: 10, output_tokens: 5 },
+        stop_reason: 'end_turn'
     };
     const resultWithTextContent = plugin.parseResponse(dataWithTextContent);
-    t.is(resultWithTextContent, 'Hello, World!');
+    t.truthy(resultWithTextContent.output_text === 'Hello, World!');
+    t.truthy(resultWithTextContent.finishReason === 'stop');
+    t.truthy(resultWithTextContent.usage);
+    t.truthy(resultWithTextContent.metadata.model === plugin.modelName);
 
-    const dataWithoutTextContent = {
+    // Test tool calls response
+    const dataWithToolCalls = {
         content: [
-            { type: 'image', url: 'http://example.com/image.jpg' }
-        ]
+            { 
+                type: 'tool_use', 
+                id: 'tool_1',
+                name: 'search_web',
+                input: { query: 'test search' }
+            }
+        ],
+        usage: { input_tokens: 15, output_tokens: 8 },
+        stop_reason: 'tool_use'
     };
-    const resultWithoutTextContent = plugin.parseResponse(dataWithoutTextContent);
-    t.deepEqual(resultWithoutTextContent, dataWithoutTextContent);
+    const resultWithToolCalls = plugin.parseResponse(dataWithToolCalls);
+    t.truthy(resultWithToolCalls.output_text === '');
+    t.truthy(resultWithToolCalls.finishReason === 'tool_calls');
+    t.truthy(resultWithToolCalls.toolCalls);
+    t.truthy(resultWithToolCalls.toolCalls.length === 1);
+    t.truthy(resultWithToolCalls.toolCalls[0].id === 'tool_1');
+    t.truthy(resultWithToolCalls.toolCalls[0].function.name === 'search_web');
+    t.truthy(resultWithToolCalls.toolCalls[0].function.arguments === '{"query":"test search"}');
 
+    // Test data without content (should return original data)
     const dataWithoutContent = {};
     const resultWithoutContent = plugin.parseResponse(dataWithoutContent);
     t.deepEqual(resultWithoutContent, dataWithoutContent);
 
+    // Test null data (should return null)
     const dataNull = null;
     const resultNull = plugin.parseResponse(dataNull);
     t.is(resultNull, dataNull);

package/tests/{claude3VertexToolConversion.test.js → unit/plugins/claude3VertexToolConversion.test.js}

@@ -1,7 +1,7 @@
 import test from 'ava';
-import Claude3VertexPlugin from '../server/plugins/claude3VertexPlugin.js';
-import { mockPathwayResolverMessages } from './mocks.js';
-import { config } from '../config.js';
+import Claude3VertexPlugin from '../../../server/plugins/claude3VertexPlugin.js';
+import { mockPathwayResolverMessages } from '../../helpers/mocks.js';
+import { config } from '../../../config.js';
 
 const { pathway, modelName, model } = mockPathwayResolverMessages;
 

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

@@ -0,0 +1,111 @@
+import test from 'ava';
+import sinon from 'sinon';
+
+const mockPathway = {
+  name: 'google_cse',
+  temperature: 0.0,
+  prompt: '',
+};
+
+const mockModel = {
+  name: 'google-cse',
+  type: 'GOOGLE-CSE',
+  url: 'https://www.googleapis.com/customsearch/v1',
+  headers: { 'Content-Type': 'application/json' },
+  requestsPerSecond: 10,
+  maxTokenLength: 200000,
+};
+
+test.beforeEach(async t => {
+  t.context.sandbox = sinon.createSandbox();
+  t.context.originalEnv = { ...process.env };
+  process.env.OPENAI_API_KEY = 'test-openai-key';
+  process.env.GOOGLE_CSE_KEY = 'test-google-key';
+  process.env.GOOGLE_CSE_CX = 'test-google-cx';
+  const module = await import('../../../server/plugins/googleCsePlugin.js');
+  const GoogleCsePlugin = module.default;
+  t.context.plugin = new GoogleCsePlugin(mockPathway, mockModel);
+});
+
+test.afterEach.always(t => {
+  t.context.sandbox.restore();
+  process.env = t.context.originalEnv;
+});
+
+test('getRequestParameters builds query params correctly', t => {
+  const { plugin } = t.context;
+  const text = 'pokemon';
+  const parameters = {
+    q: 'pokemon cards',
+    num: 5,
+    start: 2,
+    safe: 'active',
+    dateRestrict: 'w1',
+    siteSearch: 'example.com',
+    siteSearchFilter: 'i',
+    searchType: 'image',
+    gl: 'us',
+    hl: 'en',
+    lr: 'lang_en',
+    sort: 'date',
+    exactTerms: 'pikachu',
+    excludeTerms: 'fake',
+    orTerms: 'deck,booster',
+    fileType: 'pdf',
+    cx: 'override-cx',
+  };
+
+  const result = plugin.getRequestParameters(text, parameters, {});
+
+  t.deepEqual(result, {
+    data: [],
+    params: {
+      key: 'test-google-key',
+      cx: 'override-cx',
+      q: 'pokemon cards',
+      num: 5,
+      start: 2,
+      safe: 'active',
+      dateRestrict: 'w1',
+      siteSearch: 'example.com',
+      siteSearchFilter: 'i',
+      searchType: 'image',
+      gl: 'us',
+      hl: 'en',
+      lr: 'lang_en',
+      sort: 'date',
+      exactTerms: 'pikachu',
+      excludeTerms: 'fake',
+      orTerms: 'deck,booster',
+      fileType: 'pdf',
+    }
+  });
+});
+
+test('execute sets method GET and calls executeRequest', async t => {
+  const { plugin } = t.context;
+  const spy = t.context.sandbox.stub(plugin, 'executeRequest').resolves('{"items": []}');
+
+  const cortexRequest = {
+    data: null,
+    params: null,
+    method: null,
+    url: mockModel.url,
+  };
+
+  const res = await plugin.execute('pokemon', { q: 'pokemon' }, {}, cortexRequest);
+
+  t.is(res, '{"items": []}');
+  t.true(spy.calledOnce);
+  const calledWith = spy.firstCall.args[0];
+  t.is(calledWith.method, 'GET');
+  t.is(calledWith.url, 'https://www.googleapis.com/customsearch/v1');
+  t.deepEqual(calledWith.params.q, 'pokemon');
+});
+
+test('parseResponse returns JSON string', t => {
+  const { plugin } = t.context;
+  const data = { items: [{ link: 'https://example.com' }] };
+  const res = plugin.parseResponse(data);
+  t.is(res, JSON.stringify(data));
+});