@aj-archipelago/cortex 1.3.62 → 1.3.63

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' }
+  };

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

@@ -1,7 +1,7 @@
 import 'dotenv/config'
 import { ApolloServer } from '@apollo/server';
-import { config } from '../config.js';
-import typeDefsresolversFactory from '../index.js';
+import { config } from '../../config.js';
+import typeDefsresolversFactory from '../../index.js';
 
 let typeDefs;
 let resolvers;

package/tests/helpers/sseAssert.js

@@ -0,0 +1,23 @@
+import { connectToSSEEndpoint } from './sseClient.js';
+
+export async function collectSSEChunks(baseUrl, endpoint, payload) {
+  const chunks = [];
+  await connectToSSEEndpoint(baseUrl, endpoint, payload, (chunk) => {
+    chunks.push(chunk);
+  });
+  return chunks;
+}
+
+export function assertOAIChatChunkBasics(t, chunk) {
+  t.truthy(chunk.id);
+  t.is(chunk.object, 'chat.completion.chunk');
+  t.truthy(chunk.choices && chunk.choices[0]);
+  const choice = chunk.choices[0];
+  t.true('delta' in choice);
+}
+
+export function assertAnyContentDelta(chunks) {
+  return chunks.some(c => c?.choices?.[0]?.delta?.content);
+}
+
+

package/tests/helpers/sseClient.js

@@ -0,0 +1,73 @@
+import axios from 'axios';
+
+// Connects to an SSE endpoint and resolves when [DONE] is received.
+// Calls onEvent for each parsed SSE message JSON.
+export async function connectToSSEEndpoint(baseUrl, endpoint, payload, onEvent) {
+  return new Promise(async (resolve, reject) => {
+    let sawDone = false;
+    const timeout = setTimeout(() => {
+      reject(new Error('SSE timeout waiting for [DONE]'));
+    }, 8000); // 8 second timeout
+    
+    try {
+      const instance = axios.create({
+        baseURL: baseUrl,
+        responseType: 'stream',
+      });
+
+      const response = await instance.post(endpoint, payload);
+      const responseData = response.data;
+
+      const incomingMessage = Array.isArray(responseData) && responseData.length > 0
+        ? responseData[0]
+        : responseData;
+
+      let eventCount = 0;
+
+      incomingMessage.on('data', data => {
+        const events = data.toString().split('\n');
+
+        events.forEach(event => {
+          if (event.trim() === '') return;
+
+          eventCount++;
+
+          if (event.trim() === 'data: [DONE]') {
+            sawDone = true;
+            clearTimeout(timeout);
+            resolve();
+            return;
+          }
+
+          const message = event.replace(/^data: /, '');
+          try {
+            const messageJson = JSON.parse(message);
+            onEvent && onEvent(messageJson);
+          } catch (_err) {
+            // ignore lines that are not JSON
+          }
+        });
+      });
+
+      // If the underlying stream ends without a [DONE], treat as failure
+      incomingMessage.on('end', () => {
+        if (!sawDone) {
+          clearTimeout(timeout);
+          reject(new Error('SSE stream ended without [DONE]'));
+        }
+      });
+
+      incomingMessage.on('close', () => {
+        if (!sawDone) {
+          clearTimeout(timeout);
+          reject(new Error('SSE stream closed without [DONE]'));
+        }
+      });
+    } catch (error) {
+      clearTimeout(timeout);
+      reject(error);
+    }
+  });
+}
+
+

package/tests/helpers/subscriptionAssert.js

@@ -0,0 +1,11 @@
+export function assertOAIStyleDeltaMessage(t, message) {
+  const progress = message?.data?.requestProgress;
+  t.truthy(progress);
+  if (progress.data) {
+    // Should be string of serialized JSON or plain text
+    const text = JSON.parse(progress.data);
+    t.true(typeof text === 'string' || typeof text === 'object');
+  }
+}
+
+