@aj-archipelago/cortex 1.3.59 → 1.3.60

package/config/default.example.json

@@ -12,7 +12,21 @@
             "requestsPerSecond": 10,
             "maxTokenLength": 2000
         },
-
+        "azure-bing-agent": {
+            "type": "AZURE-FOUNDRY-AGENTS",
+            "url": "https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry",
+            "agentId": "asst_assistantid",
+            "headers": {
+                "Content-Type": "application/json"
+            },
+            "params": {
+                "api-version": "2025-05-01"
+            },
+            "requestsPerSecond": 10,
+            "maxTokenLength": 32768,
+            "maxReturnTokens": 4096,
+            "supportsStreaming": false
+        },
         "gemini-pro-chat": {
             "type": "GEMINI-CHAT",
             "url": "https://us-central1-aiplatform.googleapis.com/v1/projects/project-id/locations/us-central1/publishers/google/models/gemini-pro:streamGenerateContent",

package/config.js

@@ -4,6 +4,7 @@ import HandleBars from './lib/handleBars.js';
 import fs from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import GcpAuthTokenHelper from './lib/gcpAuthTokenHelper.js';
+import AzureAuthTokenHelper from './lib/azureAuthTokenHelper.js';
 import logger from './lib/logger.js';
 import PathwayManager from './lib/pathwayManager.js';
 import { readdir } from 'fs/promises';
@@ -128,6 +129,12 @@ var config = convict({
         env: 'GCP_SERVICE_ACCOUNT_KEY',
         sensitive: true
     },
+    azureServicePrincipalCredentials: {
+        format: String,
+        default: null,
+        env: 'AZURE_SERVICE_PRINCIPAL_CREDENTIALS',
+        sensitive: true
+    },
     models: {
         format: Object,
         default: {
@@ -183,6 +190,36 @@ var config = convict({
                 },
                 "maxTokenLength": 8192,
             },
+            "oai-gpt5": {
+                "type": "OPENAI-REASONING-VISION",
+                "url": "https://api.openai.com/v1/chat/completions",
+                "headers": {
+                    "Authorization": "Bearer {{OPENAI_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+                "params": {
+                    "model": "gpt-5"
+                },
+                "requestsPerSecond": 50,
+                "maxTokenLength": 1000000,
+                "maxReturnTokens": 16384,
+                "supportsStreaming": true
+            },
+            "oai-gpt5-mini": {
+                "type": "OPENAI-REASONING-VISION",
+                "url": "https://api.openai.com/v1/chat/completions",
+                "headers": {
+                    "Authorization": "Bearer {{OPENAI_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+                "params": {
+                    "model": "gpt-5-mini"
+                },
+                "requestsPerSecond": 50,
+                "maxTokenLength": 1000000,
+                "maxReturnTokens": 16384,
+                "supportsStreaming": true
+            },
             "oai-gpt4o": {
                 "type": "OPENAI-VISION",
                 "url": "https://api.openai.com/v1/chat/completions",
@@ -614,6 +651,11 @@ if (config.get('gcpServiceAccountKey')) {
     config.set('gcpAuthTokenHelper', gcpAuthTokenHelper);
 }
 
+if (config.get('azureServicePrincipalCredentials')) {
+    const azureAuthTokenHelper = new AzureAuthTokenHelper(config.getProperties());
+    config.set('azureAuthTokenHelper', azureAuthTokenHelper);
+}
+
 // Load dynamic pathways from JSON file or cloud storage
 const createDynamicPathwayManager = async (config, basePathway) => {
     const { dynamicPathwayConfig } = config.getProperties();

package/lib/azureAuthTokenHelper.js

@@ -0,0 +1,78 @@
+import fetch from 'node-fetch';
+
+class AzureAuthTokenHelper {
+  constructor(config) {
+    // Parse Azure credentials from config
+    const azureCredentials = config.azureServicePrincipalCredentials ? JSON.parse(config.azureServicePrincipalCredentials) : null;
+    
+    if (!azureCredentials) {
+      throw new Error('AZURE_SERVICE_PRINCIPAL_CREDENTIALS is missing or undefined');
+    }
+
+    // Extract required fields
+    this.tenantId = azureCredentials.tenant_id || azureCredentials.tenantId;
+    this.clientId = azureCredentials.client_id || azureCredentials.clientId;
+    this.clientSecret = azureCredentials.client_secret || azureCredentials.clientSecret;
+    this.scope = azureCredentials.scope || 'https://ai.azure.com/.default';
+
+    if (!this.tenantId || !this.clientId || !this.clientSecret) {
+      throw new Error('Azure credentials must include tenant_id, client_id, and client_secret');
+    }
+
+    this.token = null;
+    this.expiry = null;
+    this.tokenUrl = `https://login.microsoftonline.com/${this.tenantId}/oauth2/v2.0/token`;
+  }
+
+  async getAccessToken() {
+    if (!this.token || !this.isTokenValid()) {
+      await this.refreshToken();
+    }
+    return this.token;
+  }
+
+  isTokenValid() {
+    // Check if token is still valid with a 5-minute buffer
+    return !!(this.expiry && Date.now() < this.expiry.getTime() - 5 * 60 * 1000);
+  }
+
+  async refreshToken() {
+    try {
+      const formData = new URLSearchParams();
+      formData.append('client_id', this.clientId);
+      formData.append('client_secret', this.clientSecret);
+      formData.append('scope', this.scope);
+      formData.append('grant_type', 'client_credentials');
+
+      const response = await fetch(this.tokenUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: formData,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Azure token request failed: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+
+      const tokenData = await response.json();
+
+      if (!tokenData.access_token) {
+        throw new Error('Azure token response missing access_token');
+      }
+
+      this.token = tokenData.access_token;
+      
+      // Calculate expiry time (expires_in is in seconds)
+      const expiresInMs = (tokenData.expires_in || 3600) * 1000;
+      this.expiry = new Date(Date.now() + expiresInMs);
+
+    } catch (error) {
+      throw new Error(`Failed to refresh Azure token: ${error.message}`);
+    }
+  }
+}
+
+export default AzureAuthTokenHelper; 

package/lib/entityConstants.js

@@ -28,11 +28,12 @@ Your responses should be in {{language}} unless the user has expressed another p
 
     AI_TOOLS: `# Tool Instructions
 
-You have an extensive toolkit. Each time you call tool(s) you will get the result(s), evaluate, decide what's next, and chain as many steps as needed. Always honor user requests to use specific tools.
+You have an extensive toolkit. Each time you call tool(s) you will get the result(s), evaluate, decide what's next, and chain as many steps as needed. Always honor user requests to use specific tools. You must always search if you are being asked questions about current events, news, fact-checking, or information requiring citation. Your search tools work best when called in parallel to save time so if you know you will need multiple searches, call the search tool(s) in parallel.
 
 1. Search deeply & verify rigorously:
-    - Start broad and consult multiple sources, running searches in parallel where possible.
+    - Start broad and consult multiple sources, running all searches in parallel to save time.
     - Consult all available sources and cross-reference with specific searches before responding.
+    - If a tool fails or has a technical difficulty, try the backup tool automatically before giving up or reporting the error.
 
 2. Plan & sequence before acting:
     - Review the toolset first.
@@ -61,7 +62,7 @@ When searching for news, you must complete the following steps:
 
 1. Triangulate
    - Run multiple, parallel queries across all applicable sources.
-   - Request about double the number of results you want to share, then select the best results.
+   - Request at least double the number of results you want to share, then select the best results.
    - Confirm that multiple sources tell the same story.
 
 2. Check Freshness
@@ -102,7 +103,7 @@ token1 | token2        (OR operator - either token may appear (also the default
 
 # AI Search Syntax
 
-When creating a query string for your non-Bing search tools, you can use the following AI Search syntax. Important: these tools do not support AND, OR, or NOT strings as operators - you MUST use the syntax below.  E.g. you cannot use "term1 AND term2", you must use "term1 + term2".
+When creating a query string for your non-Bing, index-based search tools, you can use the following AI Search syntax. Important: these tools do not support AND, OR, or NOT strings as operators - you MUST use the syntax below.  E.g. you cannot use "term1 AND term2", you must use "term1 + term2".
 
 token1 + token2        (AND operator - both tokens must appear)
 token1 | token2        (OR operator - either token may appear (also the default if no operator is specified))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.59",
+  "version": "1.3.60",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/pathways/bing_afagent.js

@@ -0,0 +1,13 @@
+// bing_afagent.js
+// Web search tool
+
+export default {
+    inputParameters: {
+        text: ``,
+    },
+    timeout: 400,
+    enableDuplicateRequests: false,
+    model: 'azure-bing-agent',
+    useInputChunking: false
+};
+

package/pathways/gemini_15_vision.js

@@ -17,4 +17,8 @@ export default {
     useInputChunking: false,
     enableDuplicateRequests: false,
     timeout: 600,
+    geminiSafetySettings: [{category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH'}],
 }

package/pathways/system/entity/tools/sys_tool_bing_search.js

@@ -61,7 +61,7 @@ export default {
                 const errorMessages = Array.isArray(resolver.errors) 
                     ? resolver.errors.map(err => err.message || err)
                     : [resolver.errors.message || resolver.errors];
-                return JSON.stringify({ _type: "SearchError", value: errorMessages });
+                return JSON.stringify({ _type: "SearchError", value: errorMessages, recoveryMessage: "This tool failed. You should try the backup tool for this function." });
             }
 
             const parsedResponse = JSON.parse(response);

package/pathways/system/entity/tools/sys_tool_bing_search_afagent.js

@@ -0,0 +1,141 @@
+// sys_tool_bing_search_afagent.js
+// Tool pathway that handles Bing web search functionality with minimal parsing
+import { callPathway } from '../../../../lib/pathwayTools.js';
+import logger from '../../../../lib/logger.js';
+import { config } from '../../../../config.js';
+import { getSearchResultId } from '../../../../lib/util.js';
+
+export default {
+    prompt: [],
+    timeout: 300,
+    toolDefinition: { 
+        type: "function",
+        icon: "🕸️",
+        function: {
+            name: "SearchInternetBackup",
+            description: "This tool allows you to search sources on the internet by calling another agent that has Bing search access. Use this for current events, news, fact-checking, and information requiring citation. This is a backup tool for when the other internet search tools fail - it is slower so try to use the other tools first and always call this tool in parallel if you have several searches to do.",
+            parameters: {
+                type: "object",
+                properties: {
+                    text: {
+                        type: "string",
+                        description: "The complete natural language prompt describing what you want to search for. This is going to an AI agent that has Bing search access - you can be as detailed or general as you want."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["text", "userMessage"]
+            }
+        }
+    },
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+
+        // Check if Bing API key is available
+        const servicePricipalAvailable = !!config.getEnv()["AZURE_SERVICE_PRINCIPAL_CREDENTIALS"];
+        if (!servicePricipalAvailable) {
+            throw new Error("Service Principal for Bing Search Agent is not available!");
+        }
+
+        try {
+            // Call the Bing search pathway
+            //remove model from args as bing_afagent has model in its own
+            const { model, ...restArgs } = args;
+            const rawResponse = await callPathway('bing_afagent', { 
+                ...restArgs,
+            }, resolver);
+            
+            // Add error handling for malformed JSON
+            let response;
+            try {
+                response = JSON.parse(rawResponse);
+            } catch (parseError) {
+                logger.error(`Failed to parse bing_afagent response as JSON: ${parseError.message}`);
+                logger.error(`Raw response: ${rawResponse}`);
+                throw new Error(`Invalid JSON response from bing_afagent: ${parseError.message}`);
+            }
+
+            if (resolver.errors && resolver.errors.length > 0) {
+                const errorMessages = Array.isArray(resolver.errors) 
+                    ? resolver.errors.map(err => err.message || err)
+                    : [resolver.errors.message || resolver.errors];
+                return JSON.stringify({ _type: "SearchError", value: errorMessages });
+            }
+
+            // Transform response to match expected SearchResponse format
+            function transformToSearchResponse(response) {
+                let valueText = response.value || '';
+                const annotations = response.annotations || [];
+                
+                // Create a mapping from citation text to search result IDs
+                const citationToIdMap = new Map();
+                const citationPattern = /【\d+:\d+†source】/g;
+                
+                // Replace citation markers with search result IDs
+                valueText = valueText.replace(citationPattern, (match) => {
+                    if (!citationToIdMap.has(match)) {
+                        citationToIdMap.set(match, getSearchResultId());
+                    }
+                    return `:cd_source[${citationToIdMap.get(match)}]`;
+                });
+                
+                // Transform annotations to search result objects
+                const searchResults = annotations.map(annotation => {
+                    if (annotation.type === "url_citation" && annotation.url_citation) {
+                        const citationText = annotation.text;
+                        const searchResultId = citationToIdMap.get(citationText) || getSearchResultId();
+                        
+                        return {
+                            searchResultId: searchResultId,
+                            title: annotation.url_citation.title || '',
+                            url: annotation.url_citation.url || '',
+                            content: annotation.url_citation.title || annotation.url_citation.url || '', // Individual result content
+                            path: '',
+                            wireid: '',
+                            source: '',
+                            slugline: '',
+                            date: ''
+                        };
+                    }
+                    return null;
+                }).filter(result => result !== null);
+                
+                // If no annotations, create a single search result with the content
+                if (searchResults.length === 0) {
+                    searchResults.push({
+                        searchResultId: getSearchResultId(),
+                        title: '',
+                        url: '',
+                        content: valueText, // Use the full transformed text as content
+                        path: '',
+                        wireid: '',
+                        source: '',
+                        slugline: '',
+                        date: ''
+                    });
+                }
+                
+                return {
+                    transformedText: valueText, // The full text with citations replaced
+                    searchResults: searchResults // Individual search results for citation extraction
+                };
+            }
+
+            const transformedData = transformToSearchResponse(response);
+
+            resolver.tool = JSON.stringify({ toolUsed: "SearchInternetAgent2" });
+            
+            // Return the full transformed text as the main result, and include search results for citation extraction
+            return JSON.stringify({ 
+                _type: "SearchResponse", 
+                value: transformedData.searchResults,
+                text: transformedData.transformedText // The full transformed text with citations
+            });
+        } catch (e) {
+            logger.error(`Error in Bing search: ${e}`);
+            throw e;
+        }
+    }
+}; 

package/pathways/system/entity/tools/sys_tool_browser_jina.js

@@ -12,7 +12,7 @@ export default {
         icon: "🌎",
         function: {
             name: "FetchWebPageContentJina",
-            description: "This tool allows you to fetch and extract the text content from any webpage using the Jina API. This is a great fallback for web page content if you don't get a good enough response from your other browser tool.",
+            description: "This tool allows you to fetch and extract the text content from any webpage using the Jina API. This is a great backup tool for web page content if you don't get a good enough response from your other browser tool or are blocked by a website.",
             parameters: {
                 type: "object",
                 properties: {

package/pathways/system/entity/tools/sys_tool_readfile.js

@@ -22,6 +22,10 @@ export default {
     useInputChunking: false,
     enableDuplicateRequests: false,
     timeout: 600,
+    geminiSafetySettings: [{category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH'}],
     toolDefinition: [{
         type: "function",
         icon: "📄",

package/pathways/system/workspaces/workspace_applet_edit.js

@@ -182,6 +182,10 @@ export default {
     },
     // model: 'oai-gpt41',
     model: 'gemini-pro-25-vision',
+    geminiSafetySettings: [{category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH'},
+      {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH'},
+      {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH'},
+      {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH'}],
     timeout: 600,
     stream: true,
 } 

package/pathways/transcribe_gemini.js

@@ -62,6 +62,10 @@ export default {
     },
     timeout: 3600, // in seconds
     enableDuplicateRequests: false,
+    geminiSafetySettings: [{category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH'}],
 
     executePathway: async ({args, runAllPrompts, resolver}) => {
         let intervalId;

package/server/modelExecutor.js

@@ -33,6 +33,7 @@ import ApptekTranslatePlugin from './plugins/apptekTranslatePlugin.js';
 import GoogleTranslatePlugin from './plugins/googleTranslatePlugin.js';
 import GroqChatPlugin from './plugins/groqChatPlugin.js';
 import VeoVideoPlugin from './plugins/veoVideoPlugin.js';
+import AzureFoundryAgentsPlugin from './plugins/azureFoundryAgentsPlugin.js';
 
 class ModelExecutor {
     constructor(pathway, model) {
@@ -133,6 +134,9 @@ class ModelExecutor {
             case 'VEO-VIDEO':
                 plugin = new VeoVideoPlugin(pathway, model);
                 break;
+            case 'AZURE-FOUNDRY-AGENTS':
+                plugin = new AzureFoundryAgentsPlugin(pathway, model);
+                break;
             default:
                 throw new Error(`Unsupported model type: ${model.type}`);
         }

package/server/plugins/azureFoundryAgentsPlugin.js

@@ -0,0 +1,372 @@
+// AzureFoundryAgentsPlugin.js
+import ModelPlugin from './modelPlugin.js';
+import logger from '../../lib/logger.js';
+import axios from 'axios';
+
+class AzureFoundryAgentsPlugin extends ModelPlugin {
+    constructor(pathway, model) {
+        super(pathway, model);
+        this.agentId = model.agentId;
+        this.projectUrl = model.url;
+    }
+
+    // Convert to Azure Foundry Agents messages array format
+    convertToAzureFoundryMessages(context, examples, messages) {
+        let azureMessages = [];
+        
+        // Add context as a system message if provided
+        if (context) {
+            azureMessages.push({
+                role: 'system',
+                content: context,
+            });
+        }
+        
+        // Add examples to the messages array
+        if (examples && examples.length > 0) {
+            examples.forEach(example => {
+                azureMessages.push({
+                    role: example.input.author || 'user',
+                    content: example.input.content,
+                });
+                azureMessages.push({
+                    role: example.output.author || 'assistant',
+                    content: example.output.content,
+                });
+            });
+        }
+        
+        // Add remaining messages to the messages array
+        messages.forEach(message => {
+            azureMessages.push({
+                role: message.author,
+                content: message.content,
+            });
+        });
+        
+        return azureMessages;
+    }
+
+    // Set up parameters specific to the Azure Foundry Agents API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, modelPromptMessages, tokenLength, modelPrompt } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+    
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxPromptTokens();
+    
+        let requestMessages = modelPromptMessages || [{ "role": "user", "content": modelPromptText }];
+        
+        // Check if the messages are in Palm format and convert them to Azure format if necessary
+        const isPalmFormat = requestMessages.some(message => 'author' in message);
+        if (isPalmFormat) {
+            const context = modelPrompt.context || '';
+            const examples = modelPrompt.examples || [];
+            requestMessages = this.convertToAzureFoundryMessages(context, examples, modelPromptMessages);
+        }
+    
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelTargetTokenLength && this.promptParameters?.manageTokenLength) {
+            // Remove older messages until the token length is within the model's limit
+            requestMessages = this.truncateMessagesToTargetLength(requestMessages, modelTargetTokenLength);
+        }
+    
+        const requestParameters = {
+            assistant_id: this.agentId,
+            thread: {
+                messages: requestMessages
+            },
+            stream: stream || false,
+            // Add any additional parameters that might be needed
+            ...(parameters.tools && { tools: parameters.tools }),
+            ...(parameters.tool_resources && { tool_resources: parameters.tool_resources }),
+            ...(parameters.metadata && { metadata: parameters.metadata }),
+            ...(parameters.instructions && { instructions: parameters.instructions }),
+            ...(parameters.model && { model: parameters.model }),
+            ...(parameters.temperature && { temperature: parameters.temperature }),
+            ...(parameters.max_tokens && { max_tokens: parameters.max_tokens }),
+            ...(parameters.top_p && { top_p: parameters.top_p }),
+            ...(parameters.tool_choice && { tool_choice: parameters.tool_choice }),
+            ...(parameters.response_format && { response_format: parameters.response_format }),
+            ...(parameters.parallel_tool_calls && { parallel_tool_calls: parameters.parallel_tool_calls }),
+            ...(parameters.truncation_strategy && { truncation_strategy: parameters.truncation_strategy })
+        };
+    
+        return requestParameters;
+    }
+
+    // Assemble and execute the request to the Azure Foundry Agents API
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+
+        // Set up the request for Azure Foundry Agents
+        cortexRequest.url = this.requestUrl();
+        cortexRequest.data = requestParameters;
+        cortexRequest.params = { 'api-version': '2025-05-01' }; // Azure API version
+
+        // Get authentication token and add to headers
+        const azureAuthTokenHelper = this.config.get('azureAuthTokenHelper');
+        let authToken = null;
+        if (azureAuthTokenHelper) {
+            try {
+                authToken = await azureAuthTokenHelper.getAccessToken();
+            } catch (error) {
+                logger.warn(`[Azure Foundry Agent] Failed to get auth token: ${error.message}`);
+                // Continue without auth token
+            }
+        }
+        
+        cortexRequest.headers = {
+            'Content-Type': 'application/json',
+            ...cortexRequest.headers,
+            ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+        };
+
+        // Execute the initial request to create the run
+        const runResponse = await this.executeRequest(cortexRequest);
+        
+        // If we got a run response, poll for completion and get messages
+        if (runResponse && runResponse.id && runResponse.thread_id) {
+            return await this.pollForCompletion(runResponse.thread_id, runResponse.id, cortexRequest);
+        }
+        
+        return runResponse;
+    }
+
+    // Poll for run completion and retrieve messages
+    async pollForCompletion(threadId, runId, cortexRequest) {
+        const maxPollingAttempts = 60; // 60 seconds max
+        const pollingInterval = 1000; // 1 second
+        let attempts = 0;
+        
+        while (attempts < maxPollingAttempts) {
+            attempts++;
+            
+            // Wait before polling
+            await new Promise(resolve => setTimeout(resolve, pollingInterval));
+            
+            try {
+                // Add authentication token if available
+                const azureAuthTokenHelper = this.config.get('azureAuthTokenHelper');
+                let authToken = null;
+                if (azureAuthTokenHelper) {
+                    try {
+                        authToken = await azureAuthTokenHelper.getAccessToken();
+                    } catch (error) {
+                        logger.warn(`[Azure Foundry Agent] Failed to get auth token for polling: ${error.message}`);
+                        // Continue without auth token
+                    }
+                }
+                
+                const pollUrl = this.constructAzureUrl(`/threads/${threadId}/runs/${runId}`);
+                const pollResponse = await axios.get(pollUrl, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...this.model.headers,
+                        ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+                    },
+                    params: { 'api-version': '2025-05-01' }
+                });
+                const runStatus = pollResponse?.data;
+                
+                if (!runStatus) {
+                    logger.warn(`[Azure Foundry Agent] No run status received for run: ${runId}`);
+                    continue;
+                }
+                
+                // Check if run is completed
+                if (runStatus.status === 'completed') {
+                    logger.info(`[Azure Foundry Agent] Run completed successfully: ${runId}`);
+                    return await this.retrieveMessages(threadId, cortexRequest);
+                }
+                
+                // Check if run failed
+                if (runStatus.status === 'failed') {
+                    logger.error(`[Azure Foundry Agent] Run failed: ${runId}`, runStatus.lastError);
+                    return null;
+                }
+                
+                // Check if run was cancelled
+                if (runStatus.status === 'cancelled') {
+                    logger.warn(`[Azure Foundry Agent] Run was cancelled: ${runId}`);
+                    return null;
+                }
+                
+                // Continue polling for queued or in_progress status
+                if (runStatus.status === 'queued' || runStatus.status === 'in_progress') {
+                    continue;
+                }
+                
+                // Unknown status
+                logger.warn(`[Azure Foundry Agent] Unknown run status: ${runStatus.status}`);
+                break;
+                
+            } catch (error) {
+                logger.error(`[Azure Foundry Agent] Error polling run status: ${error.message}`);
+                break;
+            }
+        }
+        
+        logger.error(`[Azure Foundry Agent] Polling timeout after ${maxPollingAttempts} attempts for run: ${runId}`);
+        return null;
+    }
+
+    // Retrieve messages from the completed thread
+    async retrieveMessages(threadId, cortexRequest) {
+        try { 
+            // Add authentication token if available
+            const azureAuthTokenHelper = this.config.get('azureAuthTokenHelper');
+            let authToken = null;
+            if (azureAuthTokenHelper) {
+                try {
+                    authToken = await azureAuthTokenHelper.getAccessToken();
+                } catch (error) {
+                    logger.warn(`[Azure Foundry Agent] Failed to get auth token for messages: ${error.message}`);
+                    // Continue without auth token
+                }
+            }
+            
+            const messagesUrl = this.constructAzureUrl(`/threads/${threadId}/messages`);
+            const axiosResponse = await axios.get(messagesUrl, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.model.headers,
+                    ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+                },
+                params: { 'api-version': '2025-05-01', order: 'asc' }
+            });
+            const messagesResponse = axiosResponse?.data;
+            
+            if (!messagesResponse || !messagesResponse.data) {
+                logger.warn(`[Azure Foundry Agent] No messages received from thread: ${threadId}`);
+                return null;
+            }
+            
+            // Find the last assistant message
+            const messages = messagesResponse.data;
+            for (let i = messages.length - 1; i >= 0; i--) {
+                const message = messages[i];
+                if (message.role === 'assistant' && message.content && Array.isArray(message.content)) {
+                    const textContent = message.content.find(c => c.type === 'text' && c.text && c.text.value);
+                    if (textContent) {
+                        return JSON.stringify(textContent.text);
+                    }
+                }
+            }
+            
+            logger.warn(`[Azure Foundry Agent] No assistant messages found in thread: ${threadId}`);
+            return null;
+            
+        } catch (error) {
+            logger.error(`[Azure Foundry Agent] Error retrieving messages: ${error.message}`);
+            return null;
+        }
+    }
+
+    // Parse the response from the Azure Foundry Agents API
+    parseResponse(data) {
+        if (!data) return "";
+        
+        // If data is already a string (the final message content), return it
+        if (typeof data === 'string') {
+            return data;
+        }
+        
+        // Handle the run response format (for backward compatibility)
+        if (data.id && data.status) {
+            // This is a run response, we need to handle the status
+            if (data.status === 'completed') {
+                // The run completed successfully, but we need to get the messages
+                // This would typically be handled by polling for messages
+                return data;
+            } else if (data.status === 'failed') {
+                logger.error(`Azure Foundry Agent run failed: ${data.lastError?.message || data.last_error?.message || 'Unknown error'}`);
+                return null;
+            } else {
+                // Still in progress
+                return data;
+            }
+        }
+
+        // Handle direct message response
+        if (data.messages && Array.isArray(data.messages)) {
+            const lastMessage = data.messages[data.messages.length - 1];
+            if (lastMessage && lastMessage.content && Array.isArray(lastMessage.content)) {
+                const textContent = lastMessage.content.find(c => c.type === 'text');
+                if (textContent && textContent.text) {
+                    // Support both object { value: string } and string shapes
+                    if (typeof textContent.text === 'string') {
+                        return textContent.text;
+                    }
+                    if (typeof textContent.text.value === 'string') {
+                        return textContent.text.value;
+                    }
+                }
+            }
+        }
+
+        // Fallback to returning the entire response
+        return data;
+    }
+
+    // Override the logging function to display the messages and responses
+    logRequestData(data, responseData, prompt) {
+        const { stream, thread } = data;
+        
+        if (thread && thread.messages && thread.messages.length > 1) {
+            logger.info(`[Azure Foundry Agent request sent containing ${thread.messages.length} messages]`);
+            let totalLength = 0;
+            let totalUnits;
+            
+            thread.messages.forEach((message, index) => {
+                const content = message.content === undefined ? JSON.stringify(message) : 
+                    (Array.isArray(message.content) ? message.content.map(item => {
+                        return JSON.stringify(item);
+                    }).join(', ') : message.content);
+                const { length, units } = this.getLength(content);
+                const displayContent = this.shortenContent(content);
+
+                logger.verbose(`message ${index + 1}: role: ${message.role}, ${units}: ${length}, content: "${displayContent}"`);
+                totalLength += length;
+                totalUnits = units;
+            });
+            logger.info(`[Azure Foundry Agent request contained ${totalLength} ${totalUnits}]`);
+        } else if (thread && thread.messages && thread.messages.length === 1) {
+            const message = thread.messages[0];
+            const content = Array.isArray(message.content) ? message.content.map(item => {
+                return JSON.stringify(item);
+            }).join(', ') : message.content;
+            const { length, units } = this.getLength(content);
+            logger.info(`[Azure Foundry Agent request sent containing ${length} ${units}]`);
+            logger.verbose(`${this.shortenContent(content)}`);
+        }
+    
+        if (stream) {
+            logger.info(`[Azure Foundry Agent response received as an SSE stream]`);
+        } else {
+            const responseText = this.parseResponse(responseData);
+            if (responseText && typeof responseText === 'string') {
+                const { length, units } = this.getLength(responseText);
+                logger.info(`[Azure Foundry Agent response received containing ${length} ${units}]`);
+                logger.verbose(`${this.shortenContent(responseText)}`);
+            } else {
+                logger.info(`[Azure Foundry Agent response received: ${JSON.stringify(responseData)}]`);
+            }
+        }
+
+        prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
+    }
+
+    // Override the request URL to use the Azure Foundry Agents endpoint
+    requestUrl() {
+        // The URL should be constructed as: {projectUrl}/threads/runs
+        return `${this.projectUrl}/threads/runs`;
+    }
+
+    // Helper method to construct Azure Foundry Agents URLs
+    constructAzureUrl(path) {
+        return `${this.projectUrl}${path}`;
+    }
+}
+
+export default AzureFoundryAgentsPlugin; 

package/server/plugins/gemini15ChatPlugin.js

@@ -124,9 +124,9 @@ class Gemini15ChatPlugin extends ModelPlugin {
             topP: parameters.topP || 0.95,
             topK: parameters.topK || 40,
         },
-        safety_settings: geminiSafetySettings || undefined,
-        systemInstruction: system,
-        tools: geminiTools || undefined
+        ...(geminiSafetySettings ? {safety_settings: geminiSafetySettings} : {}),
+        ...(system ? {systemInstruction: system} : {}),
+        ...(geminiTools ? {tools: geminiTools} : {})
         };
     
         return requestParameters;

package/tests/azureAuthTokenHelper.test.js

@@ -0,0 +1,150 @@
+import test from 'ava';
+import AzureAuthTokenHelper from '../lib/azureAuthTokenHelper.js';
+
+test('should initialize with valid credentials', (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: '648085d9-6878-44a9-a76b-0223882f8268',
+      client_id: '8796f9a6-cd80-45dd-91b8-9ddf384ee42c',
+      client_secret: 'test-secret',
+      scope: 'https://ai.azure.com/.default'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  
+  t.is(azureHelper.tenantId, '648085d9-6878-44a9-a76b-0223882f8268');
+  t.is(azureHelper.clientId, '8796f9a6-cd80-45dd-91b8-9ddf384ee42c');
+  t.is(azureHelper.clientSecret, 'test-secret');
+  t.is(azureHelper.scope, 'https://ai.azure.com/.default');
+  t.is(azureHelper.tokenUrl, 'https://login.microsoftonline.com/648085d9-6878-44a9-a76b-0223882f8268/oauth2/v2.0/token');
+});
+
+test('should throw error when azureCredentials is missing', (t) => {
+  t.throws(() => {
+    new AzureAuthTokenHelper({});
+  }, { message: 'AZURE_SERVICE_PRINCIPAL_CREDENTIALS is missing or undefined' });
+});
+
+test('should throw error when required fields are missing', (t) => {
+  const invalidConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant'
+      // missing client_id and client_secret
+    })
+  };
+
+  t.throws(() => {
+    new AzureAuthTokenHelper(invalidConfig);
+  }, { message: 'Azure credentials must include tenant_id, client_id, and client_secret' });
+});
+
+test('should support both snake_case and camelCase field names', (t) => {
+  const camelCaseConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenantId: '648085d9-6878-44a9-a76b-0223882f8268',
+      clientId: '8796f9a6-cd80-45dd-91b8-9ddf384ee42c',
+      clientSecret: 'test-secret',
+      scope: 'https://ai.azure.com/.default'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(camelCaseConfig);
+  
+  t.is(azureHelper.tenantId, '648085d9-6878-44a9-a76b-0223882f8268');
+  t.is(azureHelper.clientId, '8796f9a6-cd80-45dd-91b8-9ddf384ee42c');
+  t.is(azureHelper.clientSecret, 'test-secret');
+});
+
+test('isTokenValid should return false when no token exists', (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  t.false(azureHelper.isTokenValid());
+});
+
+test('isTokenValid should return false when token is expired', (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  azureHelper.token = 'test-token';
+  azureHelper.expiry = new Date(Date.now() - 1000); // expired 1 second ago
+  t.false(azureHelper.isTokenValid());
+});
+
+test('isTokenValid should return true when token is valid with buffer', (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  azureHelper.token = 'test-token';
+  azureHelper.expiry = new Date(Date.now() + 10 * 60 * 1000); // expires in 10 minutes
+  t.true(azureHelper.isTokenValid());
+});
+
+test('isTokenValid should return false when token expires within buffer time', (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  azureHelper.token = 'test-token';
+  azureHelper.expiry = new Date(Date.now() + 3 * 60 * 1000); // expires in 3 minutes (within 5-minute buffer)
+  t.false(azureHelper.isTokenValid());
+});
+
+test('getAccessToken should return existing token if valid', async (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  azureHelper.token = 'existing-token';
+  azureHelper.expiry = new Date(Date.now() + 10 * 60 * 1000);
+
+  const token = await azureHelper.getAccessToken();
+  t.is(token, 'existing-token');
+});
+
+test('getAccessToken should throw error when token is invalid and no network available', async (t) => {
+  const mockConfig = {
+    azureServicePrincipalCredentials: JSON.stringify({
+      tenant_id: 'test-tenant',
+      client_id: 'test-client',
+      client_secret: 'test-secret'
+    })
+  };
+
+  const azureHelper = new AzureAuthTokenHelper(mockConfig);
+  // No token set, so it will try to refresh and fail
+
+  await t.throwsAsync(
+    azureHelper.getAccessToken(),
+    { message: /Failed to refresh Azure token/ }
+  );
+}); 

package/tests/azureFoundryAgents.test.js

@@ -0,0 +1,212 @@
+// azureFoundryAgents.test.js
+import test from 'ava';
+import AzureFoundryAgentsPlugin from '../server/plugins/azureFoundryAgentsPlugin.js';
+
+test.beforeEach(t => {
+    const mockPathway = {
+        name: 'test-pathway',
+        temperature: 0.7,
+        prompt: {
+            context: 'You are a helpful assistant.',
+            examples: []
+        }
+    };
+
+    const mockModel = {
+        name: 'azure-foundry-agents',
+        type: 'AZURE-FOUNDRY-AGENTS',
+        url: 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry',
+        agentId: 'asst_testid',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        maxTokenLength: 32768,
+        maxReturnTokens: 4096,
+        supportsStreaming: true
+    };
+
+    t.context.plugin = new AzureFoundryAgentsPlugin(mockPathway, mockModel);
+    t.context.mockPathway = mockPathway;
+    t.context.mockModel = mockModel;
+});
+
+test('should initialize with correct agent ID and project URL', t => {
+    const { plugin } = t.context;
+    t.is(plugin.agentId, 'asst_testid');
+    t.is(plugin.projectUrl, 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry');
+});
+
+test('should convert Palm format messages to Azure format', t => {
+    const { plugin } = t.context;
+    const context = 'You are a helpful assistant.';
+    const examples = [
+        {
+            input: { author: 'user', content: 'Hello' },
+            output: { author: 'assistant', content: 'Hi there!' }
+        }
+    ];
+    const messages = [
+        { author: 'user', content: 'How are you?' }
+    ];
+
+    const result = plugin.convertToAzureFoundryMessages(context, examples, messages);
+
+    t.deepEqual(result, [
+        { role: 'system', content: 'You are a helpful assistant.' },
+        { role: 'user', content: 'Hello' },
+        { role: 'assistant', content: 'Hi there!' },
+        { role: 'user', content: 'How are you?' }
+    ]);
+});
+
+test('should handle empty examples and context', t => {
+    const { plugin } = t.context;
+    const messages = [
+        { author: 'user', content: 'Hello' }
+    ];
+
+    const result = plugin.convertToAzureFoundryMessages('', [], messages);
+
+    t.deepEqual(result, [
+        { role: 'user', content: 'Hello' }
+    ]);
+});
+
+test('should create correct request parameters', 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 }]
+    };
+
+    const result = plugin.getRequestParameters(text, parameters, prompt);
+
+    t.is(result.assistant_id, 'asst_testid');
+    t.deepEqual(result.thread.messages, [{ role: 'user', content: text }]);
+    t.is(result.stream, false);
+});
+
+test('should parse completed run response', t => {
+    const { plugin } = t.context;
+    const mockResponse = {
+        id: 'run_123',
+        status: 'completed',
+        thread_id: 'thread_456'
+    };
+
+    const result = plugin.parseResponse(mockResponse);
+    t.deepEqual(result, mockResponse);
+});
+
+test('should parse string response (final message content)', t => {
+    const { plugin } = t.context;
+    const mockResponse = 'Hello! How can I help you?';
+
+    const result = plugin.parseResponse(mockResponse);
+    t.is(result, 'Hello! How can I help you?');
+});
+
+test('should handle failed run response', t => {
+    const { plugin } = t.context;
+    const mockResponse = {
+        id: 'run_123',
+        status: 'failed',
+        lastError: { message: 'Something went wrong' }
+    };
+
+    const result = plugin.parseResponse(mockResponse);
+    t.is(result, null);
+});
+
+test('should parse message content from response', t => {
+    const { plugin } = t.context;
+    const mockResponse = {
+        messages: [
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'text',
+                        text: { value: 'Hello! How can I help you?' }
+                    }
+                ]
+            }
+        ]
+    };
+
+    const result = plugin.parseResponse(mockResponse);
+    t.is(result, 'Hello! How can I help you?');
+});
+
+test('should return empty string for null response', t => {
+    const { plugin } = t.context;
+    const result = plugin.parseResponse(null);
+    t.is(result, '');
+});
+
+test('should return correct Azure Foundry Agents endpoint', t => {
+    const { plugin } = t.context;
+    const url = plugin.requestUrl();
+    t.is(url, 'https://archipelago-foundry-resource.services.ai.azure.com/api/projects/archipelago-foundry/threads/runs');
+});
+
+test('should be able to access azureAuthTokenHelper from config', (t) => {
+  // Mock config with azureAuthTokenHelper
+  const mockConfig = {
+    get: (key) => {
+      if (key === 'azureAuthTokenHelper') {
+        return {
+          getAccessToken: async () => 'mock-token'
+        };
+      }
+      return null;
+    }
+  };
+
+  // Mock pathway and model
+  const mockPathway = {};
+  const mockModel = {
+    url: 'https://test.azure.com/api/projects/test',
+    agentId: 'test-agent-id',
+    headers: { 'Content-Type': 'application/json' }
+  };
+
+  // Create plugin instance
+  const plugin = new AzureFoundryAgentsPlugin(mockPathway, mockModel);
+  
+  // Mock the config property
+  plugin.config = mockConfig;
+
+  // Test that we can access the auth helper
+  const authHelper = plugin.config.get('azureAuthTokenHelper');
+  t.truthy(authHelper);
+  t.is(typeof authHelper.getAccessToken, 'function');
+});
+
+test('should handle missing azureAuthTokenHelper gracefully', (t) => {
+  // Mock config without azureAuthTokenHelper
+  const mockConfig = {
+    get: (key) => null
+  };
+
+  // Mock pathway and model
+  const mockPathway = {};
+  const mockModel = {
+    url: 'https://test.azure.com/api/projects/test',
+    agentId: 'test-agent-id',
+    headers: { 'Content-Type': 'application/json' }
+  };
+
+  // Create plugin instance
+  const plugin = new AzureFoundryAgentsPlugin(mockPathway, mockModel);
+  
+  // Mock the config property
+  plugin.config = mockConfig;
+
+  // Test that we can access the auth helper (should be null)
+  const authHelper = plugin.config.get('azureAuthTokenHelper');
+  t.is(authHelper, null);
+});