@aj-archipelago/cortex 1.3.62 → 1.3.63

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

@@ -0,0 +1,141 @@
+// sys_tool_google_search.js
+// Tool pathway that handles Google Custom Search functionality
+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: "SearchInternetGoogle",
+            description: "Search the web using Google Custom Search (CSE). This is a simple pass-through tool: it calls Google CSE with your parameters and returns normalized results with unique IDs for citation. Prefer strict time filters and reputable sources via CSE parameters.",
+            parameters: {
+                type: "object",
+                properties: {
+                    q: {
+                        type: "string",
+                        description: "The complete query to pass to Google CSE using Google's search syntax."
+                    },
+                    num: {
+                        type: "integer",
+                        description: "Number of results to return (1-10). Default 10."
+                    },
+                    start: {
+                        type: "integer",
+                        description: "The index of the first result to return for pagination (1-based)."
+                    },
+                    safe: {
+                        type: "string",
+                        description: "SafeSearch setting: 'off' or 'active'."
+                    },
+                    dateRestrict: {
+                        type: "string",
+                        description: "Restrict results to recent content (e.g., 'd1' for past day, 'w1' week, 'm1' month, 'y1' year)."
+                    },
+                    siteSearch: {
+                        type: "string",
+                        description: "Restrict results to a specific site or domain."
+                    },
+                    siteSearchFilter: {
+                        type: "string",
+                        description: "'e' to exclude or 'i' to include the siteSearch restriction."
+                    },
+                    cx: {
+                        type: "string",
+                        description: "Optional: override the default Google Custom Search Engine ID for this call."
+                    },
+                    searchType: {
+                        type: "string",
+                        description: "Set to 'image' to search for images."
+                    },
+                    gl: {
+                        type: "string",
+                        description: "Country code for results (geolocation)."
+                    },
+                    hl: {
+                        type: "string",
+                        description: "Interface language."
+                    },
+                    lr: {
+                        type: "string",
+                        description: "Restrict results by language (e.g., 'lang_en')."
+                    },
+                    sort: {
+                        type: "string",
+                        description: "Sorting expression (e.g., 'date')."
+                    },
+                    exactTerms: {
+                        type: "string",
+                        description: "Terms that must appear in the results."
+                    },
+                    excludeTerms: {
+                        type: "string",
+                        description: "Terms to exclude from results."
+                    },
+                    orTerms: {
+                        type: "string",
+                        description: "Alternative terms; results must include at least one."
+                    },
+                    fileType: {
+                        type: "string",
+                        description: "Restrict results by file type (e.g., 'pdf')."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["q", "userMessage"]
+            }
+        }
+    },
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        // Check if Google CSE credentials are available
+        const env = config.getEnv();
+        const googleKey = env["GOOGLE_CSE_KEY"];
+        const googleCx = env["GOOGLE_CSE_CX"];
+        if (!googleKey || !googleCx) {
+            throw new Error("Google Custom Search is not available - missing GOOGLE_CSE_KEY and/or GOOGLE_CSE_CX");
+        }
+
+        try {
+            // Pass-through: call Google CSE with provided args
+            const response = await callPathway('google_cse', { 
+                ...args
+            }, resolver);
+
+            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, recoveryMessage: "This tool failed. You should try the backup tool for this function." });
+            }
+
+            const parsedResponse = JSON.parse(response);
+
+            const results = [];
+            const items = parsedResponse.items || [];
+            // Normalize results from Google CSE items
+            for (const item of items) {
+                results.push({
+                    searchResultId: getSearchResultId(),
+                    title: item.title || item.htmlTitle || '',
+                    url: item.link || item.formattedUrl || '',
+                    content: item.snippet || item.htmlSnippet || ''
+                });
+            }
+
+            resolver.tool = JSON.stringify({ toolUsed: "GoogleSearch" });
+            return JSON.stringify({ _type: "SearchResponse", value: results });
+        } catch (e) {
+            logger.error(`Error in Google CSE search: ${e}`);
+            throw e;
+        }
+    }
+}; 

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

@@ -0,0 +1,237 @@
+// sys_tool_grok_x_search.js
+// Tool pathway that handles Grok Live Search functionality specifically for X platform search
+import { callPathway } from '../../../../lib/pathwayTools.js';
+import logger from '../../../../lib/logger.js';
+import { getSearchResultId, extractCitationTitle } from '../../../../lib/util.js';
+
+export default {
+    prompt: [],
+    timeout: 300,
+    inputParameters: {
+        text: '',
+        userMessage: '',
+        includedHandles: [''],
+        excludedHandles: [''],
+        minFavorites: 0,
+        minViews: 0,
+        maxResults: 10
+    },
+    toolDefinition: { 
+        type: "function",
+        icon: "🔍",
+        function: {
+            name: "SearchXPlatform",
+            description: "This tool allows you to search the X platform (formerly Twitter) for current posts, discussions, and real-time information. Use this for finding recent social media content, trending topics, public opinions, and real-time updates. Always call this tool in parallel rather than serially if you have several searches to do as it will be faster.",
+            parameters: {
+                type: "object",
+                properties: {
+                    text: {
+                        type: "string",
+                        description: "The complete natural language prompt describing what you want to search for on X platform. This can include topics, hashtags, usernames, or general queries about current events and discussions."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    },
+                    includedHandles: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional array of X handles to include in search (e.g., ['OpenAI', 'AnthropicAI', 'xai']). Maximum 10 handles.",
+                        maxItems: 10
+                    },
+                    excludedHandles: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional array of X handles to exclude from search. Maximum 10 handles. Cannot be used in conjunction with includedHandles.",
+                        maxItems: 10
+                    },
+                    minFavorites: {
+                        type: "number",
+                        description: "Popularity filter: Minimum number of favorites (likes) for posts to include",
+                        minimum: 0
+                    },
+                    minViews: {
+                        type: "number",
+                        description: "Popularity filter: Minimum number of views for posts to include",
+                        minimum: 0
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of search results to return (default: 10, max: 50)",
+                        minimum: 1,
+                        maximum: 50,
+                        default: 10
+                    }
+                },
+                required: ["text", "userMessage"]
+            }
+        }
+    },
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        
+        try {
+            // Build search parameters for X platform search
+            const searchParameters = {
+                mode: 'auto',
+                return_citations: true,
+                max_search_results: args.maxResults || 10,
+                sources: [{
+                    type: 'x',
+                    ...(args.includedHandles && args.includedHandles.length > 0 && {
+                        included_x_handles: args.includedHandles
+                    }),
+                    ...(args.excludedHandles && args.excludedHandles.length > 0 && {
+                        excluded_x_handles: args.excludedHandles
+                    }),
+                    ...(args.minFavorites && {
+                        post_favorite_count: args.minFavorites
+                    }),
+                    ...(args.minViews && {
+                        post_view_count: args.minViews
+                    })
+                }]
+            };
+
+            // Call the Grok Live Search pathway
+            const { model, ...restArgs } = args;
+            const result = await callPathway('grok_live_search', { 
+                ...restArgs,
+                search_parameters: JSON.stringify(searchParameters)
+            }, resolver);
+            
+            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(resultData, result) {
+                // Extract text and citations from CortexResponse
+                const valueText = result || '';
+                const citations = resultData.citations || [];
+                
+                // Create a mapping from citation URLs to search result IDs
+                const citationToIdMap = new Map();
+                const finalSearchResults = [];
+                
+                // Process citations array
+                if (Array.isArray(citations)) {
+                    citations.forEach(citation => {
+                        const searchResultId = citation.searchResultId || getSearchResultId();
+                        
+                        // Check if we already have this URL in searchResults
+                        const existingResult = finalSearchResults.find(r => r.url === citation.url);
+                        if (!existingResult) {
+                            finalSearchResults.push({
+                                searchResultId: searchResultId,
+                                title: citation.title || extractCitationTitle(citation.url),
+                                url: citation.url,
+                                content: citation.content || citation.title || extractCitationTitle(citation.url),
+                                path: '',
+                                wireid: '',
+                                source: 'X Platform',
+                                slugline: '',
+                                date: ''
+                            });
+                        }
+                        
+                        // Create mapping for URL replacement
+                        if (citation.url) {
+                            citationToIdMap.set(citation.url, searchResultId);
+                        }
+                    });
+                }
+                
+                // Extract inline citations from the text in format [1](https://example.com) or [1(https://example.com)]
+                const inlineCitationPattern = /\[(\d+)\]\(([^)]+)\)|\[(\d+)\(([^)]+)\)\]/g;
+                let match;
+                const inlineCitations = new Set();
+                
+                while ((match = inlineCitationPattern.exec(valueText)) !== null) {
+                    // Handle both formats: [1](url) and [1(url)]
+                    const citationNumber = match[1] || match[3];
+                    const citationUrl = match[2] || match[4];
+                    inlineCitations.add(citationUrl);
+                    
+                    // If we haven't already processed this URL, add it to search results
+                    if (!citationToIdMap.has(citationUrl)) {
+                        const searchResultId = getSearchResultId();
+                        citationToIdMap.set(citationUrl, searchResultId);
+                        
+                        finalSearchResults.push({
+                            searchResultId: searchResultId,
+                            title: extractCitationTitle(citationUrl),
+                            url: citationUrl,
+                            content: extractCitationTitle(citationUrl),
+                            path: '',
+                            wireid: '',
+                            source: 'X Platform',
+                            slugline: '',
+                            date: ''
+                        });
+                    }
+                }
+                
+                // Replace inline citations with our standard format
+                let transformedText = valueText.replace(inlineCitationPattern, (match, num1, url1, num2, url2) => {
+                    const url = url1 || url2;
+                    const searchResultId = citationToIdMap.get(url);
+                    return searchResultId ? `:cd_source[${searchResultId}]` : match;
+                });
+                
+                // Also handle simple numbered citations [1] format
+                transformedText = transformedText.replace(/\[(\d+)\]/g, (match, num) => {
+                    const citationIndex = parseInt(num) - 1;
+                    if (citations[citationIndex]) {
+                        const citation = citations[citationIndex];
+                        // If citation is already in searchResults format, use its searchResultId
+                        if (citation.searchResultId) {
+                            return `:cd_source[${citation.searchResultId}]`;
+                        }
+                        // Otherwise, try to find by URL
+                        const url = typeof citation === 'string' ? citation : citation.url;
+                        const searchResultId = citationToIdMap.get(url);
+                        return searchResultId ? `:cd_source[${searchResultId}]` : match;
+                    }
+                    return match;
+                });
+                
+                // If no citations found anywhere, create a single search result with the content
+                if (finalSearchResults.length === 0) {
+                    finalSearchResults.push({
+                        searchResultId: getSearchResultId(),
+                        title: 'X Platform Search Results',
+                        url: 'https://x.com/search', // Provide a valid URL for X platform search
+                        content: transformedText,
+                        path: '',
+                        wireid: '',
+                        source: 'X Platform',
+                        slugline: '',
+                        date: ''
+                    });
+                }
+                
+                return {
+                    transformedText: transformedText,
+                    searchResults: finalSearchResults
+                };
+            }
+
+            resolver.pathwayResultData.toolUsed = 'SearchXPlatform';
+           
+            // Transform the CortexResponse and return the search response
+            const transformedData = transformToSearchResponse(resolver.pathwayResultData, result);
+            return JSON.stringify({ 
+                _type: "SearchResponse", 
+                value: transformedData.searchResults,
+                text: transformedData.transformedText
+            });
+        } catch (e) {
+            logger.error(`Error in Grok X Platform search: ${e}`);
+            throw e;
+        }
+    }
+};

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

@@ -15,7 +15,7 @@ export default {
         icon: "🎨",
         function: {
             name: "GenerateImage",
-            description: "Use when asked to create, generate, or generate revisions of visual content. Any time the user asks you for a picture, a selfie, artwork, a drawing or if you want to illustrate something for the user, you can use this tool to generate any sort of image from cartoon to photo realistic.",
+            description: "Use when asked to create, generate, or generate revisions of visual content. Any time the user asks you for a picture, a selfie, artwork, a drawing or if you want to illustrate something for the user, you can use this tool to generate any sort of image from cartoon to photo realistic. After you have generated the image, you must include the image in your response to show it to the user.",
             parameters: {
                 type: "object",
                 properties: {

package/pathways/system/rest_streaming/sys_claude_37_sonnet.js

@@ -0,0 +1,21 @@
+// sys_claude_37_sonnet.js
+// override handler for claude-37-sonnet
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'claude-37-sonnet-vertex',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'claude-3.7-sonnet',
+} 

package/pathways/system/rest_streaming/sys_claude_41_opus.js

@@ -0,0 +1,21 @@
+// sys_claude_41_opus.js
+// override handler for claude-41-opus
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'claude-41-opus-vertex',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'claude-4.1-opus',
+}

package/pathways/system/rest_streaming/sys_claude_4_sonnet.js

@@ -0,0 +1,21 @@
+// sys_claude_4_sonnet.js
+// override handler for claude-4-sonnet
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'claude-4-sonnet-vertex',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'claude-4-sonnet',
+}

package/pathways/system/rest_streaming/sys_google_gemini_25_flash.js

@@ -0,0 +1,25 @@
+// sys_google_gemini_25_flash.js
+// override handler for gemini-flash-25-vision
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'gemini-flash-25-vision',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'gemini-flash-25',
+    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/rest_streaming/{sys_google_gemini_chat.js → sys_google_gemini_25_pro.js}

@@ -1,5 +1,5 @@
-// sys_google_gemini_chat.js
-// override handler for gemini-chat
+// sys_google_gemini_25_pro.js
+// override handler for gemini-pro-25-vision
 
 import { Prompt } from '../../../server/prompt.js';
 
@@ -12,10 +12,12 @@ export default {
     ],
     inputParameters: {
         messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
     },
-    model: 'gemini-pro-chat',
+    model: 'gemini-pro-25-vision',
     useInputChunking: false,
-    emulateOpenAIChatModel: 'gemini-pro-chat',
+    emulateOpenAIChatModel: 'gemini-pro-25',
     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'},

package/pathways/system/rest_streaming/sys_grok_4.js

@@ -0,0 +1,23 @@
+// sys_grok_4.js
+// override handler for grok-4
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        stream: false,
+        search_parameters: '',
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'xai-grok-4',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'grok-4'
+} 

package/pathways/system/rest_streaming/sys_grok_4_fast_non_reasoning.js

@@ -0,0 +1,23 @@
+// sys_grok_4_fast_non_reasoning.js
+// override handler for grok-4-fast-non-reasoning
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        stream: false,
+        search_parameters: '',
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'xai-grok-4-fast-non-reasoning',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'grok-4-fast-non-reasoning'
+}

package/pathways/system/rest_streaming/sys_grok_4_fast_reasoning.js

@@ -0,0 +1,23 @@
+// sys_grok_4_fast_reasoning.js
+// override handler for grok-4-fast-reasoning
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        stream: false,
+        search_parameters: '',
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'xai-grok-4-fast-reasoning',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'grok-4-fast-reasoning'
+}

package/pathways/system/rest_streaming/sys_openai_chat.js

@@ -12,6 +12,9 @@ export default {
     ],
     inputParameters: {
         messages: [],
+        tools: '',
+        tool_choice: 'auto',
+        functions: '',
     },
     model: 'oai-gpt4o',
     useInputChunking: false,

package/pathways/system/rest_streaming/sys_openai_chat_gpt41.js

@@ -0,0 +1,22 @@
+// sys_openai_chat_gpt41.js
+// override handler for gpt-41
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        functions: '',
+        tool_choice: 'auto',
+    },
+    model: 'oai-gpt41',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'gpt-4.1',
+}

package/pathways/system/rest_streaming/sys_openai_chat_gpt41_mini.js

@@ -0,0 +1,21 @@
+// sys_openai_chat_gpt41_mini.js
+// override handler for gpt-41-mini
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'oai-gpt41-mini',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'gpt-4.1-mini',
+}

package/pathways/system/rest_streaming/sys_openai_chat_gpt41_nano.js

@@ -0,0 +1,21 @@
+// sys_openai_chat_gpt41_nano.js
+// override handler for gpt-41-nano
+
+import { Prompt } from '../../../server/prompt.js';
+
+export default {
+    prompt:
+    [
+        new Prompt({ messages: [
+            "{{messages}}",
+        ]}),
+    ],
+    inputParameters: {
+        messages: [{role: '', content: []}],
+        tools: '',
+        tool_choice: 'auto',
+    },
+    model: 'oai-gpt41-nano',
+    useInputChunking: false,
+    emulateOpenAIChatModel: 'gpt-4.1-nano',
+}