@aj-archipelago/cortex 1.3.62 → 1.3.64

package/server/plugins/openAiVisionPlugin.js

@@ -2,6 +2,7 @@ import OpenAIChatPlugin from './openAiChatPlugin.js';
 import logger from '../../lib/logger.js';
 import { requestState } from '../requestState.js';
 import { addCitationsToResolver } from '../../lib/pathwayTools.js';
+import CortexResponse from '../../lib/cortexResponse.js';
 function safeJsonParse(content) {
     try {
         const parsedContent = JSON.parse(content);
@@ -113,16 +114,14 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
         }
         if (stream) {
             logger.info(`[response received as an SSE stream]`);
-        } else {
-            const parsedResponse = this.parseResponse(responseData);
-            
-            if (typeof parsedResponse === 'string') {
-                const { length, units } = this.getLength(parsedResponse);
+        } else {           
+            if (typeof responseData === 'string') {
+                const { length, units } = this.getLength(responseData);
                 logger.info(`[response received containing ${length} ${units}]`);
-                logger.verbose(`${this.shortenContent(parsedResponse)}`);
+                logger.verbose(`${this.shortenContent(responseData)}`);
             } else {
                 logger.info(`[response received containing object]`);
-                logger.verbose(`${JSON.stringify(parsedResponse)}`);
+                logger.verbose(`${JSON.stringify(responseData)}`);
             }
         }
 
@@ -135,15 +134,6 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
 
         requestParameters.messages = await this.tryParseMessages(requestParameters.messages);
 
-        // Add tools support if provided in parameters
-        if (parameters.tools) {
-            requestParameters.tools = parameters.tools;
-        }
-
-        if (parameters.tool_choice) {
-            requestParameters.tool_choice = parameters.tool_choice;
-        }
-
         const modelMaxReturnTokens = this.getModelMaxReturnTokens();
         const maxTokensPrompt = this.promptParameters.max_tokens;
         const maxTokensModel = this.getModelMaxTokenLength() * (1 - this.getPromptTokenRatio());
@@ -165,7 +155,7 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             ...(cortexRequest.data || {}),
             ...requestParameters,
         };
-        cortexRequest.params = {}; // query params
+        cortexRequest.params = {};
         cortexRequest.stream = stream;
 
         return this.executeRequest(cortexRequest);
@@ -179,24 +169,30 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             return data;
         }
 
-        // if we got a choices array back with more than one choice, return the whole array
-        if (choices.length > 1) {
-            return choices;
-        }
-
         const choice = choices[0];
         const message = choice.message;
+        if (!message) {
+            return null;
+        }
+
+        // Create standardized CortexResponse object
+        const cortexResponse = new CortexResponse({
+            output_text: message.content || "",
+            finishReason: choice.finish_reason || 'stop',
+            usage: data.usage || null,
+            metadata: {
+                model: this.modelName
+            }
+        });
 
-        // Handle tool calls in the response
+        // Handle tool calls
         if (message.tool_calls) {
-            return {
-                role: message.role,
-                content: message.content || "",
-                tool_calls: message.tool_calls
-            };
+            cortexResponse.toolCalls = message.tool_calls;
+        } else if (message.function_call) {
+            cortexResponse.functionCall = message.function_call;
         }
 
-        return message.content || "";
+        return cortexResponse;
     }
 
     processStreamEvent(event, requestProgress) {
@@ -210,7 +206,6 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             let parsedMessage;
             try {
                 parsedMessage = JSON.parse(event.data);
-                requestProgress.data = event.data;
             } catch (error) {
                 // Clear buffers on error
                 this.toolCallsBuffer = [];
@@ -228,6 +223,23 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
             }
 
             const delta = parsedMessage?.choices?.[0]?.delta;
+            
+            // Check if this is an empty/idle event that we should skip
+            const isEmptyEvent = !delta || 
+                (Object.keys(delta).length === 0) || 
+                (Object.keys(delta).length === 1 && delta.content === '') ||
+                (Object.keys(delta).length === 1 && delta.tool_calls && delta.tool_calls.length === 0);
+            
+            // Skip publishing empty events unless they have a finish_reason
+            const hasFinishReason = parsedMessage?.choices?.[0]?.finish_reason;
+            
+            if (isEmptyEvent && !hasFinishReason) {
+                // Return requestProgress without setting data to prevent publishing
+                return requestProgress;
+            }
+            
+            // Set the data for non-empty events or events with finish_reason
+            requestProgress.data = event.data;
 
             // Accumulate content
             if (delta?.content) {
@@ -268,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/server/resolver.js

@@ -1,5 +1,7 @@
 import { fulfillWithTimeout } from '../lib/promiser.js';
 import { PathwayResolver } from './pathwayResolver.js';
+import CortexResponse from '../lib/cortexResponse.js';
+import { withRequestLoggingDisabled } from '../lib/logger.js';
 
 // This resolver uses standard parameters required by Apollo server:
 // (parent, args, contextValue, info)
@@ -19,18 +21,40 @@ const rootResolver = async (parent, args, contextValue, info) => {
     let result = null;
 
     try {
-        result = await fulfillWithTimeout(pathway.resolver(parent, args, contextValue, info), pathway.timeout);
+        const execWithTimeout = () => fulfillWithTimeout(pathway.resolver(parent, args, contextValue, info), pathway.timeout);
+        if (pathway.requestLoggingDisabled === true) {
+            result = await withRequestLoggingDisabled(() => execWithTimeout());
+        } else {
+            result = await execWithTimeout();
+        }
     } catch (error) {
         pathwayResolver.logError(error);
         result = error.message || error.toString();
     }
+
+    if (result instanceof CortexResponse) {
+        // Use the smart mergeResultData method that handles CortexResponse objects
+        pathwayResolver.pathwayResultData = pathwayResolver.mergeResultData(result);
+        result = result.output_text;
+    }
+
+    let resultData = pathwayResolver.pathwayResultData ? JSON.stringify(pathwayResolver.pathwayResultData) : null;
     
-    const { warnings, errors, previousResult, savedContextId, tool } = pathwayResolver;
-    
+    const { warnings, errors, previousResult, savedContextId, tool } = pathwayResolver;    
+
     // Add request parameters back as debug
     const debug = pathwayResolver.prompts.map(prompt => prompt.debugInfo || '').join('\n').trim();
     
-    return { debug, result, warnings, errors, previousResult, tool, contextId: savedContextId }
+    return { 
+        debug, 
+        result, 
+        resultData,
+        warnings, 
+        errors, 
+        previousResult, 
+        tool, 
+        contextId: savedContextId 
+    }
 }
 
 // This resolver is used by the root resolver to process the request

package/server/rest.js

@@ -36,6 +36,101 @@ const chunkTextIntoTokens = (() => {
     };
 })();
 
+// Helper functions to reduce code duplication
+const resolveModelName = (modelName, openAIChatModels, openAICompletionModels, isChat = false) => {
+    if (modelName.startsWith('ollama-')) {
+        const pathwayName = isChat ? 'sys_ollama_chat' : 'sys_ollama_completion';
+        return { pathwayName, isOllama: true };
+    } else {
+        const modelMap = isChat ? openAIChatModels : openAICompletionModels;
+        const pathwayName = modelMap[modelName] || modelMap['*'];
+        return { pathwayName, isOllama: false };
+    }
+};
+
+const handleModelNotFound = (res, modelName) => {
+    res.status(404).json({
+        error: `Model ${modelName} not found.`,
+    });
+};
+
+const extractResponseData = (pathwayResponse) => {
+    if (typeof pathwayResponse === 'string') {
+        return { resultText: pathwayResponse, resultData: null };
+    }
+    return {
+        resultText: pathwayResponse.result || "",
+        resultData: pathwayResponse.resultData || null
+    };
+};
+
+const parseToolCalls = (resultData, resultText) => {
+    let messageContent = resultText;
+    let toolCalls = null;
+    let functionCall = null;
+    let finishReason = 'stop';
+
+    // First check if we have structured response data from the pathway response
+    if (resultData) {
+        try {
+            const parsedResultData = typeof resultData === 'string' ? JSON.parse(resultData) : resultData;
+            
+            // resultData contains the full CortexResponse object
+            if (parsedResultData && parsedResultData.toolCalls) {
+                toolCalls = parsedResultData.toolCalls;
+                finishReason = 'tool_calls';
+            } else if (parsedResultData && parsedResultData.functionCall) {
+                functionCall = parsedResultData.functionCall;
+                finishReason = 'function_call';
+            }
+        } catch (e) {
+            // If parsing structured response fails, continue with regular parsing
+        }
+    }
+
+    // If no tool data found, try parsing the result text as before for backward compatibility
+    if (!toolCalls && !functionCall) {
+        try {
+            const parsedResponse = JSON.parse(resultText);
+            
+            // Check if this is a tool calls response
+            if (parsedResponse.role === 'assistant' && parsedResponse.hasOwnProperty('tool_calls')) {
+                if (parsedResponse.tool_calls) {
+                    toolCalls = parsedResponse.tool_calls;
+                    messageContent = parsedResponse.content || "";
+                    finishReason = 'tool_calls';
+                }
+            } else if (parsedResponse.tool_calls) {
+                toolCalls = parsedResponse.tool_calls;
+                messageContent = parsedResponse.content || "";
+                finishReason = 'tool_calls';
+            }
+            // Check if this is a legacy function call response
+            else if (parsedResponse.role === 'assistant' && parsedResponse.hasOwnProperty('function_call')) {
+                if (parsedResponse.function_call) {
+                    functionCall = parsedResponse.function_call;
+                    messageContent = parsedResponse.content || "";
+                    finishReason = 'function_call';
+                }
+            } else if (parsedResponse.function_call) {
+                functionCall = parsedResponse.function_call;
+                messageContent = parsedResponse.content || "";
+                finishReason = 'function_call';
+            }
+        } catch (e) {
+            // If parsing fails, treat as regular text response
+            messageContent = resultText;
+        }
+    }
+
+    return { messageContent, toolCalls, functionCall, finishReason };
+};
+
+const generateResponseId = (prefix) => {
+    const requestId = uuidv4();
+    return `${prefix}-${requestId}`;
+};
+
 const processRestRequest = async (server, req, pathway, name, parameterMap = {}) => {
     const fieldVariableDefs = pathway.typeDef(pathway).restDefinition || [];
 
@@ -51,6 +146,8 @@ const processRestRequest = async (server, req, pathway, name, parameterMap = {})
                     msg.content.map(item => JSON.stringify(item)) : 
                     msg.content
             }));
+        } else if (type === '[String]' && Array.isArray(value)) {
+            return value;
         } else {
             return value;
         }
@@ -67,6 +164,20 @@ const processRestRequest = async (server, req, pathway, name, parameterMap = {})
         return acc;
     }, {});
 
+    // Add tools to variables if they exist in the request
+    if (req.body.tools) {
+        variables.tools = JSON.stringify(req.body.tools);
+    }
+    
+    if (req.body.tool_choice) {
+        variables.tool_choice = typeof req.body.tool_choice === 'string' ? req.body.tool_choice : JSON.stringify(req.body.tool_choice);
+    }
+    
+    // Add functions to variables if they exist in the request (legacy function calling)
+    if (req.body.functions) {
+        variables.functions = JSON.stringify(req.body.functions);
+    }
+
     const variableParams = fieldVariableDefs.map(({ name, type }) => `$${name}: ${type}`).join(', ');
     const queryArgs = fieldVariableDefs.map(({ name }) => `${name}: $${name}`).join(', ');
 
@@ -76,10 +187,19 @@ const processRestRequest = async (server, req, pathway, name, parameterMap = {})
                         contextId
                         previousResult
                         result
+                        resultData
+                        tool
+                        warnings
+                        errors
+                        debug
                     }
                 }
             `;
 
+    // Debug: Log the variables being passed
+    logger.debug(`REST endpoint variables: ${JSON.stringify(variables, null, 2)}`);
+    logger.debug(`REST endpoint query: ${query}`);
+    
     const result = await server.executeOperation({ query, variables });
 
     // if we're streaming and there are errors, we return a standard error code
@@ -89,9 +209,27 @@ const processRestRequest = async (server, req, pathway, name, parameterMap = {})
         }
     }
     
-    // otherwise errors can just be returned as a string
-    const resultText = result?.body?.singleResult?.data?.[name]?.result || result?.body?.singleResult?.errors?.[0]?.message || "";
-    return resultText;
+    // For non-streaming, return both result and tool fields
+    const pathwayData = result?.body?.singleResult?.data?.[name];
+    if (pathwayData) {
+        return {
+            result: pathwayData.result || "",
+            resultData: pathwayData.resultData || null,
+            tool: pathwayData.tool || null,
+            errors: pathwayData.errors || null,
+            warnings: pathwayData.warnings || null
+        };
+    }
+    
+    // If no pathway data, return error message
+    const errorMessage = result?.body?.singleResult?.errors?.[0]?.message || "";
+    return {
+        result: errorMessage,
+        resultData: null,
+        tool: null,
+        errors: errorMessage ? [errorMessage] : null,
+        warnings: null
+    };
 };
 
 const processIncomingStream = (requestId, res, jsonResponse, pathway) => {
@@ -150,12 +288,30 @@ const processIncomingStream = (requestId, res, jsonResponse, pathway) => {
         if (jsonResponse.object === 'text_completion') {
             jsonResponse.choices[0].text = inputText;
         } else {
+            // Ensure delta object exists
+            if (!jsonResponse.choices[0].delta) {
+                jsonResponse.choices[0].delta = {};
+            }
             jsonResponse.choices[0].delta.content = inputText;
         }
 
         return jsonResponse;
     }
 
+    const fillJsonResponseWithToolCalls = (jsonResponse, toolCalls, finishReason) => {
+        jsonResponse.choices[0].finish_reason = finishReason;
+        if (jsonResponse.object === 'text_completion') {
+            // Handle text completion tool calls if needed
+        } else {
+            // Ensure delta object exists
+            if (!jsonResponse.choices[0].delta) {
+                jsonResponse.choices[0].delta = {};
+            }
+            jsonResponse.choices[0].delta.tool_calls = toolCalls;
+        }
+        return jsonResponse;
+    }
+
     startStream(res);
 
     // If the requestId is an error message, we can't continue
@@ -191,6 +347,21 @@ const processIncomingStream = (requestId, res, jsonResponse, pathway) => {
                 return;
             }
 
+            // Check if this is a tool call response
+            try {
+                const parsedData = JSON.parse(stringData);
+                if (parsedData.tool_calls) {
+                    // Send tool calls as a single chunk
+                    fillJsonResponseWithToolCalls(jsonResponse, parsedData.tool_calls, "tool_calls");
+                    sendStreamData(jsonResponse);
+                    safeUnsubscribe();
+                    finishStream(res, jsonResponse);
+                    return;
+                }
+            } catch (e) {
+                // Not JSON, treat as regular text
+            }
+
             chunkTextIntoTokens(stringData, false, useSingleTokenStream).forEach(token => {
                 fillJsonResponse(jsonResponse, token, null);
                 sendStreamData(jsonResponse);
@@ -224,6 +395,67 @@ const processIncomingStream = (requestId, res, jsonResponse, pathway) => {
                 return;
             }
 
+            // Check if this is a streaming event with tool calls
+            if (messageJson.choices && messageJson.choices[0] && messageJson.choices[0].delta) {
+                const delta = messageJson.choices[0].delta;
+                const finishReason = messageJson.choices[0].finish_reason;
+                
+                // Handle tool calls in streaming events
+                if (delta.tool_calls) {
+                    fillJsonResponseWithToolCalls(jsonResponse, delta.tool_calls, finishReason || "tool_calls");
+                    sendStreamData(jsonResponse);
+                    
+                    if (finishReason === "tool_calls" || progress === 1) {
+                        safeUnsubscribe();
+                        finishStream(res, jsonResponse);
+                    }
+                    return;
+                }
+                
+                // Handle the case where we get an empty delta with finish_reason: "tool_calls"
+                if (finishReason === "tool_calls" && Object.keys(delta).length === 0) {
+    
+                    safeUnsubscribe();
+                    finishStream(res, jsonResponse);
+                    return;
+                }
+                
+                // Handle function calls in streaming events
+                if (delta.function_call) {
+                    // Ensure delta object exists
+                    if (!jsonResponse.choices[0].delta) {
+                        jsonResponse.choices[0].delta = {};
+                    }
+                    jsonResponse.choices[0].delta.function_call = delta.function_call;
+                    jsonResponse.choices[0].finish_reason = finishReason || "function_call";
+                    sendStreamData(jsonResponse);
+                    
+                    if (finishReason === "function_call") {
+                        safeUnsubscribe();
+                        finishStream(res, jsonResponse);
+                    }
+                    return;
+                }
+                
+                // Handle regular content in streaming events
+                if (delta.content !== undefined) {
+                    if (delta.content === null) {
+                        // Skip null content chunks
+                        return;
+                    }
+                    chunkTextIntoTokens(delta.content, false, useSingleTokenStream).forEach(token => {
+                        fillJsonResponse(jsonResponse, token, null);
+                        sendStreamData(jsonResponse);
+                    });
+                    
+                    if (finishReason === "stop") {
+                        safeUnsubscribe();
+                        finishStream(res, jsonResponse);
+                    }
+                    return;
+                }
+            }
+
             let content = '';
             if (messageJson.choices) {
                 const { text, delta } = messageJson.choices[0];
@@ -232,6 +464,13 @@ const processIncomingStream = (requestId, res, jsonResponse, pathway) => {
                 content = messageJson.candidates[0].content.parts[0].text;
             } else if (messageJson.content) {
                 content = messageJson.content?.[0]?.text || '';
+            } else if (messageJson.tool_calls) {
+                // Handle tool calls in streaming
+                fillJsonResponseWithToolCalls(jsonResponse, messageJson.tool_calls, "tool_calls");
+                sendStreamData(jsonResponse);
+                safeUnsubscribe();
+                finishStream(res, jsonResponse);
+                return;
             } else {
                 content = messageJson;
             }
@@ -289,7 +528,8 @@ function buildRestEndpoints(pathways, app, server, config) {
                 }
             } else {
                 app.post(`/rest/${name}`, async (req, res) => {
-                    const resultText = await processRestRequest(server, req, pathway, name);
+                    const pathwayResponse = await processRestRequest(server, req, pathway, name);
+                    const { resultText } = extractResponseData(pathwayResponse);
                     res.send(resultText);
                 });
             }
@@ -298,29 +538,21 @@ function buildRestEndpoints(pathways, app, server, config) {
         // Create OpenAI compatible endpoints
         app.post('/v1/completions', async (req, res) => {
             const modelName = req.body.model || 'gpt-3.5-turbo';
-            let pathwayName;
-
-            if (modelName.startsWith('ollama-')) {
-                pathwayName = 'sys_ollama_completion';
-                req.body.ollamaModel = modelName.replace('ollama-', '');
-            } else {
-                pathwayName = openAICompletionModels[modelName] || openAICompletionModels['*'];
-            }
+            const { pathwayName, isOllama } = resolveModelName(modelName, openAIChatModels, openAICompletionModels, false);
 
             if (!pathwayName) {
-                res.status(404).json({
-                    error: `Model ${modelName} not found.`,
-                });
+                handleModelNotFound(res, modelName);
                 return;
             }
 
-            const pathway = pathways[pathwayName];
-
-            const parameterMap = {
-                text: 'prompt'
-            };
+            if (isOllama) {
+                req.body.ollamaModel = modelName.replace('ollama-', '');
+            }
 
-            const resultText = await processRestRequest(server, req, pathway, pathwayName, parameterMap);
+            const pathway = pathways[pathwayName];
+            const parameterMap = { text: 'prompt' };
+            const pathwayResponse = await processRestRequest(server, req, pathway, pathwayName, parameterMap);
+            const { resultText } = extractResponseData(pathwayResponse);
 
             const jsonResponse = {
                 id: `cmpl`,
@@ -341,50 +573,46 @@ function buildRestEndpoints(pathways, app, server, config) {
             if (Boolean(req.body.stream)) {
                 jsonResponse.id = `cmpl-${resultText}`;
                 jsonResponse.choices[0].finish_reason = null;
-
                 processIncomingStream(resultText, res, jsonResponse, pathway);
             } else {
-                const requestId = uuidv4();
-                jsonResponse.id = `cmpl-${requestId}`;
+                jsonResponse.id = generateResponseId('cmpl');
                 res.json(jsonResponse);
             }
         });
         
         app.post('/v1/chat/completions', async (req, res) => {
             const modelName = req.body.model || 'gpt-3.5-turbo';
-            let pathwayName;
-
-            if (modelName.startsWith('ollama-')) {
-                pathwayName = 'sys_ollama_chat';
-                req.body.ollamaModel = modelName.replace('ollama-', '');
-            } else {
-                pathwayName = openAIChatModels[modelName] || openAIChatModels['*'];
-            }
+            const { pathwayName, isOllama } = resolveModelName(modelName, openAIChatModels, openAICompletionModels, true);
 
             if (!pathwayName) {
-                res.status(404).json({
-                    error: `Model ${modelName} not found.`,
-                });
+                handleModelNotFound(res, modelName);
                 return;
             }
 
-            const pathway = pathways[pathwayName];
+            if (isOllama) {
+                req.body.ollamaModel = modelName.replace('ollama-', '');
+            }
 
-            const resultText = await processRestRequest(server, req, pathway, pathwayName);
+            const pathway = pathways[pathwayName];
+            const pathwayResponse = await processRestRequest(server, req, pathway, pathwayName);
+            const { resultText, resultData } = extractResponseData(pathwayResponse);
+            const { messageContent, toolCalls, functionCall, finishReason } = parseToolCalls(resultData, resultText);
 
             const jsonResponse = {
                 id: `chatcmpl`,
-                object: "chat.completion",
+                object: Boolean(req.body.stream) ? "chat.completion.chunk" : "chat.completion",
                 created: Date.now(),
                 model: req.body.model,
                 choices: [
                     {
                         message: {
                             role: "assistant",
-                            content: resultText
+                            content: messageContent,
+                            ...(toolCalls && { tool_calls: toolCalls }),
+                            ...(functionCall && { function_call: functionCall })
                         },
                         index: 0,
-                        finish_reason: "stop"
+                        finish_reason: finishReason
                     }
                 ],
             };
@@ -392,23 +620,12 @@ function buildRestEndpoints(pathways, app, server, config) {
             // eslint-disable-next-line no-extra-boolean-cast
             if (Boolean(req.body.stream)) {
                 jsonResponse.id = `chatcmpl-${resultText}`;
-                jsonResponse.choices[0] = {
-                    delta: {
-                        role: "assistant",
-                        content: resultText
-                    },
-                    finish_reason: null
-                }
-                jsonResponse.object = "chat.completion.chunk";
-
+                jsonResponse.choices[0].finish_reason = null;
                 processIncomingStream(resultText, res, jsonResponse, pathway);
             } else {
-                const requestId = uuidv4();
-                jsonResponse.id = `chatcmpl-${requestId}`;
-
+                jsonResponse.id = generateResponseId('chatcmpl');
                 res.json(jsonResponse);
             }
-
         });
 
         app.get('/v1/models', async (req, res) => {

package/server/typeDef.js

@@ -39,6 +39,7 @@ const getPathwayTypeDef = (name, returnType) => {
   return `type ${name} {
     debug: String
     result: ${returnType}
+    resultData: String
     previousResult: String
     warnings: [String]
     errors: [String]

package/tests/{mocks.js → helpers/mocks.js}

@@ -1,4 +1,4 @@
-import { Prompt } from '../server/prompt.js';
+import { Prompt } from '../../server/prompt.js';
 
 export const mockConfig = {
     get: (key) => {
@@ -92,4 +92,7 @@ export const mockConfig = {
       }),
   };
 
-  export const mockModelEndpoints = { testModel: { name: 'testModel', url: 'https://api.example.com/testModel', type: 'OPENAI-COMPLETION' }};
+  export const mockModelEndpoints = { 
+    testModel: { name: 'testModel', url: 'https://api.example.com/testModel', type: 'OPENAI-COMPLETION' },
+    anotherModel: { name: 'anotherModel', url: 'https://api.example.com/anotherModel', type: 'OPENAI-CHAT' }
+  };