@aj-archipelago/cortex 1.3.62 → 1.3.64

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

@@ -1,8 +1,8 @@
 // test/ModelPlugin.test.js
 import test from 'ava';
-import ModelPlugin from '../server/plugins/modelPlugin.js';
-import HandleBars from '../lib/handleBars.js';
-import { mockConfig, mockPathwayString, mockPathwayFunction, mockPathwayMessages, mockPathwayResolverString } from './mocks.js';
+import ModelPlugin from '../../../server/plugins/modelPlugin.js';
+import HandleBars from '../../../lib/handleBars.js';
+import { mockConfig, mockPathwayString, mockPathwayFunction, mockPathwayMessages, mockPathwayResolverString } from '../../helpers/mocks.js';
 
 const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_PROMPT_TOKEN_RATIO = 1.0;

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

@@ -1,8 +1,8 @@
 import test from 'ava';
-import OpenAIVisionPlugin from '../server/plugins/openAiVisionPlugin.js';
-import Claude3VertexPlugin from '../server/plugins/claude3VertexPlugin.js';
-import Gemini15VisionPlugin from '../server/plugins/gemini15VisionPlugin.js';
-import GeminiVisionPlugin from '../server/plugins/geminiVisionPlugin.js';
+import OpenAIVisionPlugin from '../../../server/plugins/openAiVisionPlugin.js';
+import Claude3VertexPlugin from '../../../server/plugins/claude3VertexPlugin.js';
+import Gemini15VisionPlugin from '../../../server/plugins/gemini15VisionPlugin.js';
+import GeminiVisionPlugin from '../../../server/plugins/geminiVisionPlugin.js';
 
 // Mock pathway and model for plugin initialization
 const mockPathway = { name: 'test', temperature: 0.7 };

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

@@ -1,7 +1,7 @@
 import test from 'ava';
-import OpenAIChatPlugin from '../server/plugins/openAiChatPlugin.js';
-import { mockPathwayResolverMessages } from './mocks.js';
-import { config } from '../config.js';
+import OpenAIChatPlugin from '../../../server/plugins/openAiChatPlugin.js';
+import { mockPathwayResolverMessages } from '../../helpers/mocks.js';
+import { config } from '../../../config.js';
 
 const { pathway, modelName, model } = mockPathwayResolverMessages;
 
@@ -107,7 +107,16 @@ test('parseResponse', (t) => {
         ],
     };
     const result = plugin.parseResponse(data);
-    t.is(result, 'Sure, I can help John who is 30 years old.');
+    
+    // Verify it's a CortexResponse object
+    t.truthy(result);
+    t.is(typeof result, 'object');
+    t.is(result.constructor.name, 'CortexResponse');
+    
+    
+    // Verify the content using string conversion (triggers toString automatically)
+    t.is(String(result), 'Sure, I can help John who is 30 years old.');
+    t.is(result.finishReason, 'stop');
 });
 
 // Test the logRequestData function

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

@@ -1,7 +1,7 @@
 import test from 'ava';
-import OpenAIVisionPlugin from '../server/plugins/openAiVisionPlugin.js';
-import { mockPathwayResolverMessages } from './mocks.js';
-import { config } from '../config.js';
+import OpenAIVisionPlugin from '../../../server/plugins/openAiVisionPlugin.js';
+import { mockPathwayResolverMessages } from '../../helpers/mocks.js';
+import { config } from '../../../config.js';
 
 const { pathway, modelName, model } = mockPathwayResolverMessages;
 
@@ -71,18 +71,22 @@ test('Tool call response handling', async (t) => {
 
     const result = plugin.parseResponse(responseData);
     
-    t.deepEqual(result, {
-        role: 'assistant',
-        content: 'I will check the weather for you.',
-        tool_calls: [{
-            id: 'call_123',
-            type: 'function',
-            function: {
-                name: 'get_weather',
-                arguments: '{"location": "Bogotá, Colombia"}'
-            }
-        }]
-    });
+    // Verify it's a CortexResponse object
+    t.truthy(result);
+    t.is(typeof result, 'object');
+    t.is(result.constructor.name, 'CortexResponse');
+    
+    // Verify the content
+    t.is(result.output_text, 'I will check the weather for you.');
+    t.is(result.finishReason, 'tool_calls');
+    
+    // Verify tool calls
+    t.truthy(result.toolCalls);
+    t.is(result.toolCalls.length, 1);
+    t.is(result.toolCalls[0].id, 'call_123');
+    t.is(result.toolCalls[0].type, 'function');
+    t.is(result.toolCalls[0].function.name, 'get_weather');
+    t.is(result.toolCalls[0].function.arguments, '{"location": "Bogotá, Colombia"}');
 });
 
 // Test tool result message handling
@@ -177,18 +181,22 @@ test('Error handling in tool calls', async (t) => {
 
     const result = plugin.parseResponse(responseData);
     
-    t.deepEqual(result, {
-        role: 'assistant',
-        content: 'I will check the weather for you.',
-        tool_calls: [{
-            id: 'call_123',
-            type: 'function',
-            function: {
-                name: 'get_weather',
-                arguments: 'invalid json'
-            }
-        }]
-    });
+    // Verify it's a CortexResponse object
+    t.truthy(result);
+    t.is(typeof result, 'object');
+    t.is(result.constructor.name, 'CortexResponse');
+    
+    // Verify the content
+    t.is(result.output_text, 'I will check the weather for you.');
+    t.is(result.finishReason, 'tool_calls');
+    
+    // Verify tool calls
+    t.truthy(result.toolCalls);
+    t.is(result.toolCalls.length, 1);
+    t.is(result.toolCalls[0].id, 'call_123');
+    t.is(result.toolCalls[0].type, 'function');
+    t.is(result.toolCalls[0].function.name, 'get_weather');
+    t.is(result.toolCalls[0].function.arguments, 'invalid json');
 });
 
 // Test multiple tool calls in sequence

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

@@ -1,11 +1,11 @@
 import test from 'ava';
 import fs from 'fs';
 import path from 'path';
-import { encode } from '../lib/encodeCache.js';
-import { getFirstNToken } from '../server/chunker.js';
-import Claude3VertexPlugin from '../server/plugins/claude3VertexPlugin.js';
-import ModelPlugin from '../server/plugins/modelPlugin.js';
-import { mockPathwayResolverMessages } from './mocks.js';
+import { encode } from '../../../lib/encodeCache.js';
+import { getFirstNToken } from '../../../server/chunker.js';
+import Claude3VertexPlugin from '../../../server/plugins/claude3VertexPlugin.js';
+import ModelPlugin from '../../../server/plugins/modelPlugin.js';
+import { mockPathwayResolverMessages } from '../../helpers/mocks.js';
 
 const { pathway, model } = mockPathwayResolverMessages;
 

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];
+});

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

@@ -1,6 +1,6 @@
 import test from 'ava';
 import sinon from 'sinon';
-import { PathwayResolver } from '../server/pathwayResolver.js';
+import { PathwayResolver } from '../../../server/pathwayResolver.js';
 
 // Mock configuration
 const mockModel = {
@@ -118,7 +118,7 @@ test('resolver uses correct model', (t) => {
 
 test('pathway has fallback pathway parameter', async (t) => {
     // Import the actual pathway to test the new parameter
-    const pathway = await import('../pathways/translate_apptek.js');
+    const pathway = await import('../../../pathways/translate_apptek.js');
     
     t.truthy(pathway.default.inputParameters.fallbackPathway);
     t.is(pathway.default.inputParameters.fallbackPathway, 'translate_groq');
@@ -126,7 +126,7 @@ test('pathway has fallback pathway parameter', async (t) => {
 
 test('pathway has executePathway function', async (t) => {
     // Import the actual pathway to test the executePathway function
-    const pathway = await import('../pathways/translate_apptek.js');
+    const pathway = await import('../../../pathways/translate_apptek.js');
     
     t.truthy(pathway.default.executePathway);
     t.is(typeof pathway.default.executePathway, 'function');

package/tests/{streaming.test.js → unit/plugins.streaming/plugin_stream_events.test.js}

@@ -1,30 +1,14 @@
 import test from 'ava';
-import serverFactory from '../index.js';
-import { PathwayResolver } from '../server/pathwayResolver.js';
-import OpenAIChatPlugin from '../server/plugins/openAiChatPlugin.js';
-import GeminiChatPlugin from '../server/plugins/geminiChatPlugin.js';
-import Gemini15ChatPlugin from '../server/plugins/gemini15ChatPlugin.js';
-import Claude3VertexPlugin from '../server/plugins/claude3VertexPlugin.js';
-import { config } from '../config.js';
+import { PathwayResolver } from '../../../server/pathwayResolver.js';
+import OpenAIChatPlugin from '../../../server/plugins/openAiChatPlugin.js';
+import GeminiChatPlugin from '../../../server/plugins/geminiChatPlugin.js';
+import Gemini15ChatPlugin from '../../../server/plugins/gemini15ChatPlugin.js';
+import Claude3VertexPlugin from '../../../server/plugins/claude3VertexPlugin.js';
+import { config } from '../../../config.js';
 
 let testServer;
 
-test.before(async () => {
-  process.env.CORTEX_ENABLE_REST = 'true';
-  const { server, startServer } = await serverFactory();
-  startServer && await startServer();
-  testServer = server;
-});
-
-test.after.always('cleanup', async () => {
-  if (testServer) {
-    await testServer.stop();
-  }
-});
-
-// Helper function to create a PathwayResolver with a specific plugin
 function createResolverWithPlugin(pluginClass, modelName = 'test-model') {
-  // Map plugin classes to their corresponding model types
   const pluginToModelType = {
     OpenAIChatPlugin: 'OPENAI-VISION',
     GeminiChatPlugin: 'GEMINI-VISION',
@@ -59,12 +43,10 @@ function createResolverWithPlugin(pluginClass, modelName = 'test-model') {
   return resolver;
 }
 
-// Test OpenAI Chat Plugin Streaming
 test('OpenAI Chat Plugin - processStreamEvent handles content chunks correctly', async t => {
   const resolver = createResolverWithPlugin(OpenAIChatPlugin);
   const plugin = resolver.modelExecutor.plugin;
   
-  // Test regular content chunk
   const contentEvent = {
     data: JSON.stringify({
       id: 'test-id',
@@ -79,7 +61,6 @@ test('OpenAI Chat Plugin - processStreamEvent handles content chunks correctly',
   t.is(progress.data, contentEvent.data);
   t.falsy(progress.progress);
   
-  // Test stream end
   const endEvent = {
     data: JSON.stringify({
       id: 'test-id',
@@ -94,39 +75,32 @@ test('OpenAI Chat Plugin - processStreamEvent handles content chunks correctly',
   t.is(progress.progress, 1);
 });
 
-// Test Gemini Chat Plugin Streaming
 test('Gemini Chat Plugin - processStreamEvent handles content chunks correctly', async t => {
   const resolver = createResolverWithPlugin(GeminiChatPlugin);
   const plugin = resolver.modelExecutor.plugin;
   
-  // Test regular content chunk
   const contentEvent = {
     data: JSON.stringify({
       candidates: [{
-        content: {
-          parts: [{ text: 'test content' }]
-        },
+        content: { parts: [{ text: 'test content' }] },
         finishReason: null
       }]
     })
   };
   
   let progress = plugin.processStreamEvent(contentEvent, {});
-  t.truthy(progress.data, 'Should have data');
+  t.truthy(progress.data);
   const parsedData = JSON.parse(progress.data);
-  t.truthy(parsedData.candidates, 'Should have candidates array');
-  t.truthy(parsedData.candidates[0].content, 'Should have content object');
-  t.truthy(parsedData.candidates[0].content.parts, 'Should have parts array');
-  t.is(parsedData.candidates[0].content.parts[0].text, 'test content', 'Content should match');
+  t.truthy(parsedData.candidates);
+  t.truthy(parsedData.candidates[0].content);
+  t.truthy(parsedData.candidates[0].content.parts);
+  t.is(parsedData.candidates[0].content.parts[0].text, 'test content');
   t.falsy(progress.progress);
   
-  // Test stream end with STOP
   const endEvent = {
     data: JSON.stringify({
       candidates: [{
-        content: {
-          parts: [{ text: '' }]
-        },
+        content: { parts: [{ text: '' }] },
         finishReason: 'STOP'
       }]
     })
@@ -136,17 +110,13 @@ test('Gemini Chat Plugin - processStreamEvent handles content chunks correctly',
   t.is(progress.progress, 1);
 });
 
-// Test Gemini 15 Chat Plugin Streaming
 test('Gemini 15 Chat Plugin - processStreamEvent handles safety blocks', async t => {
   const resolver = createResolverWithPlugin(Gemini15ChatPlugin);
   const plugin = resolver.modelExecutor.plugin;
   
-  // Test safety block
   const safetyEvent = {
     data: JSON.stringify({
-      candidates: [{
-        safetyRatings: [{ blocked: true }]
-      }]
+      candidates: [{ safetyRatings: [{ blocked: true }] }]
     })
   };
   
@@ -155,12 +125,10 @@ test('Gemini 15 Chat Plugin - processStreamEvent handles safety blocks', async t
   t.is(progress.progress, 1);
 });
 
-// Test Claude 3 Vertex Plugin Streaming
 test('Claude 3 Vertex Plugin - processStreamEvent handles message types', async t => {
   const resolver = createResolverWithPlugin(Claude3VertexPlugin);
   const plugin = resolver.modelExecutor.plugin;
   
-  // Test message start
   const startEvent = {
     data: JSON.stringify({
       type: 'message_start',
@@ -171,27 +139,20 @@ test('Claude 3 Vertex Plugin - processStreamEvent handles message types', async
   let progress = plugin.processStreamEvent(startEvent, {});
   t.true(JSON.parse(progress.data).choices[0].delta.role === 'assistant');
   
-  // Test content block
   const contentEvent = {
     data: JSON.stringify({
       type: 'content_block_delta',
-      delta: {
-        type: 'text_delta',
-        text: 'test content'
-      }
+      delta: { type: 'text_delta', text: 'test content' }
     })
   };
   
   progress = plugin.processStreamEvent(contentEvent, {});
   t.true(JSON.parse(progress.data).choices[0].delta.content === 'test content');
   
-  // Test message stop
-  const stopEvent = {
-    data: JSON.stringify({
-      type: 'message_stop'
-    })
-  };
+  const stopEvent = { data: JSON.stringify({ type: 'message_stop' }) };
   
   progress = plugin.processStreamEvent(stopEvent, {});
   t.is(progress.progress, 1);
-});
+});
+
+

package/helper-apps/mogrt-handler/tests/test-files/test.gif

@@ -1 +0,0 @@
-test preview gif content

package/helper-apps/mogrt-handler/tests/test-files/test.mogrt

@@ -1 +0,0 @@
-test mogrt content

package/helper-apps/mogrt-handler/tests/test-files/test.mp4

@@ -1 +0,0 @@
-test preview mp4 content

package/pathways/system/rest_streaming/sys_openai_chat_gpt4.js

@@ -1,19 +0,0 @@
-// sys_openai_chat_gpt4.js
-// override handler for gpt-4
-
-import { Prompt } from '../../../server/prompt.js';
-
-export default {
-    prompt:
-    [
-        new Prompt({ messages: [
-            "{{messages}}",
-        ]}),
-    ],
-    inputParameters: {
-        messages: [],
-    },
-    model: 'oai-gpt4',
-    useInputChunking: false,
-    emulateOpenAIChatModel: 'gpt-4',
-}